diff --git a/CHANGELOG.md b/CHANGELOG.md index 5b5508478..3a63d7aa8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,24 @@ versions, and the entries below say what each tag does and does not claim. ## Unreleased +- Certificate E as kernel-term data (SPEC.md §17.17, `SP-14`; stage 1 of #89, + stage 5 of #27). The composition certificate of every production root is no + longer written as Lean text by `production/certificate.rs`: the compiler + builds it as a native core module of schema `lexlean/core-module/2`, the + lemma types read from the native preservation library and instantiated + binder by binder (`production/kernel.rs`), the recursive groups' theorems as + recursor terms, and the one core backend renders it to the Lean verification + compiles. The verify record holds the module in the authoring notation + (`…/Compose/RustStd.lex.tex` in place of `.lean`), which reads back to the + data byte for byte, and `preservation.json` binds those bytes. A certificate + held as data is audited row by row (imports, kinds, safety, exact axiom + policies, forbidden constants) and the audit module prints and checks the + axioms of every one of its rows. The statements of the 76 certificates E of + the four corpora are those the text stated, kernel term for kernel term + (`tests/preservation-certificates/E-STATEMENTS.md`). Certificates A and B are + still Lean text, so the data certificate is rendered outside the module + system until they follow. Languages 1.0 and 1.1 have no certificates and are + untouched. No diagnostic code is new; the register gains `SP-14` (383 rows with `SP-13`, `RB-09`, and `PX-13`). - Program equalities over all inputs (#117, SPEC.md §17.12, `PF-20`..`PF-23`, no new diagnostic code). Language 1.2 orders `Int` and every fixed-width integer type with `<=` and `<`, by mathematical value; language 1.1 keeps diff --git a/CONFORMANCE.md b/CONFORMANCE.md index 7ab236682..e0cf5693d 100644 --- a/CONFORMANCE.md +++ b/CONFORMANCE.md @@ -338,6 +338,7 @@ the error registry does not sanction (R5, `ERRORS.md`). | `SP-11` | `build` | Every production root of examples/production, examples/production-coverage, examples/models, and examples/reasoning is rendered in each of its targets as a package that builds under the pinned Rust toolchain, and on the seeded inputs of the differential, through the root and through its boundary entry on valid and invalid inputs, the printed outcome of each package equals the interpreter's outcome, which the declared Rust machine reproduces; that the compiler agrees with the machine the certificates are about is build evidence, never a premise of a proof. | | `SP-12` | `build` | The preservation library is LexLean source: every module of its registry is one language-1.2 native core module, the library project holds no file of Lean source, and no Lean file anywhere in the release tree declares its namespace or lies under its module root; the registry lists only the modules, and the declarations, their exact axiom policies, the constructors of the correspondence, and the cases of its soundness theorem are read from the native data, which the compiler embeds, hashes into the language-1.2 semantics, and generates the Lean of every verification from. The one Lean text a generated library module carries beside its data is the decoder of core module 2, which loads native modules. | | `SP-13` | `build` | Certificate text writes every list and array of any length as a term the pinned Lean elaborates without binders: one of at most 32 elements as a literal and a longer one as a chain of List.cons, so that no certificate holds a literal Lean splits under let binders; a root calling a function of 33 parameters with 33 operands, a root copying a record of 33 fields, and a root matching on 33 constructors of one field each verify through the whole pipeline, and none of their certificates writes a literal of more than 32 elements. | +| `SP-14` | `build` | Certificate E of every production root is kernel-term data: a native core module of schema lexlean/core-module/2 that the compiler builds from the lowered program, the layout, and the recorded types of the preservation library's lemmas, every argument and universe level explicit, which the one core backend renders to the Lean that verification compiles and whose record is the authoring notation, reading back to the data byte for byte; its theorems state what §17.17 states for the composition, each row pins its axioms exactly and the audit module prints and checks them, a certificate held as data is audited row by row and never as text (no axiom row, no forbidden constant, imports within the environment), and a planted wrong lemma, a changed statement, a forged crate reference, or an added axiom is refused. | ## production diff --git a/README.md b/README.md index b0598495f..9b53c9ab3 100644 --- a/README.md +++ b/README.md @@ -138,7 +138,7 @@ just vv # the complete normative acceptance gate (SPEC.md §9.2) just release # vv, then the §30 release criterion; refused until 1.0.0 ``` -All 391 registered conformance IDs are implemented and pass; `just vv` runs clean from a checkout with the pinned toolchain installed. +All 392 registered conformance IDs are implemented and pass; `just vv` runs clean from a checkout with the pinned toolchain installed. The differential against the independent generator `lean4-prod` (SPEC.md §17.19, `OR-01`..`OR-08`) acquires it at its pinned commit: from the checkout `LEXLEAN_ORACLE_DIR` names, or by fetching the commit with `git` into the Cargo target directory (`LEXLEAN_ORACLE_CACHE` overrides), and builds it with the pinned Lean and Rust toolchains. It is validation evidence only and no input to any identity. An oracle that cannot be acquired, is not the pinned files, or fails is unavailable: that fails the gate on Linux x86-64 and is printed as `NOT VALIDATED` elsewhere, and is never reported as agreement. @@ -170,7 +170,7 @@ Every row is validated by `just vv`; the IDs link the claim to its register row, | The canonical Rust backend: a closed, checked Rust AST whose every construct corresponds to the calculus; hygienic identifiers, single ownership with last-use and component moves, exact failure typing, and no hidden allocation; contiguous lists with constant-work cells; a closed runtime library boundary of stated machine primitives; deterministic packages with checked exports, a declared lint gate, and provenance | `RB-01`..`RB-09` | `build` | | GNAF requests over the calculus: an optimizer-independent complete-system universe, a machine contract that accounts every action, scalar and Pareto orders without weighting, fail-closed validation, and kernel-checked answers and authority vectors | `GN-01`..`GN-08` | `build` | | GNAF certification: certificates that prove a global optimum, an argmin, or a complete Pareto frontier over the independent universe from a premise for every system, a library proving the checker sound, closed transformation schemas, local normality kept distinct from optimality, a bridge from a representation metric to execution cost, and honest non-global statuses | `GC-01`..`GC-11` | `build` | -| Semantic preservation from the source to the calculus: a validated lowering of every production root, a kernel-checked certificate per root relating the lowered program to the source denotation with exact width predicates, a differential evaluator, a proof library that is LexLean source (native core modules migrated once from the Lean it replaces, its Lean generated by the compiler) pinned by exact axioms, certificate checking in verification, a declared Rust machine on which every rendering is evaluated, certificate B relating every rendering to its program, certificate E composing them end to end, boundary validators, and a rustc differential of the declared machine | `SP-01`..`SP-13` | `build` | +| Semantic preservation from the source to the calculus: a validated lowering of every production root, a kernel-checked certificate per root relating the lowered program to the source denotation with exact width predicates, a differential evaluator, a proof library that is LexLean source (native core modules migrated once from the Lean it replaces, its Lean generated by the compiler) pinned by exact axioms, certificate checking in verification, a declared Rust machine on which every rendering is evaluated, certificate B relating every rendering to its program, certificate E composing them end to end, boundary validators, and a rustc differential of the declared machine | `SP-01`..`SP-14` | `build` | | Language-1.2 models: content-addressed typed artifacts, contracts with sound validators, exact deterministic, rule, statistical, neural, and composite realizations, generated evidence obligations restated in Lean, checked runtime boundaries, and their identity, production, and verification | `MD-01`..`MD-12` | `build` | | The differential validation oracle: `lean4-prod` pinned by commit and content hash as validation evidence only, a corpus of every production root and one probe per runtime construct, a comparison of acceptance, contract, behavior, and resources that never compares bytes, versioned tables of known differences and of constructs outside the overlap, planted discrepancies detected, failures that are unavailable rather than validated, and its isolation from every identity | `OR-01`..`OR-08` | `build` | | The production export contract: a stable, versioned `lexlean::api::production` façade and its CLI through which a consumer compiles production roots to certified Rust packages; closed requests refused before Lean on every root, target, pin, evidence, path, and package defect; results binding every output to the source, semantic, compiler-semantics, target, compiler-input, preservation, and certificate identities with unforgeable certification; deterministic, confined, offline bundles; source-free replay; versioned schemas; each output's effects and what `recursion` asks of the host | `PX-01`..`PX-13` | `build` | diff --git a/SPEC.md b/SPEC.md index b1164213d..efffc4262 100644 --- a/SPEC.md +++ b/SPEC.md @@ -5363,6 +5363,35 @@ encoders are, with the library's lemmas for every primitive and container value. A certificate E that does not compile silently, fails its replay, or whose theorem's axioms are not exactly the three above is `LLV7016`. +**Certificate E as data.** Certificate E is not Lean text. The compiler +builds it as a native core module of schema `lexlean/core-module/2` +(§17.10): the terms above as kernel terms, every argument and universe level +written. A lemma's type is read from the native preservation library and +instantiated one binder at a time, so the implicit program, crate, and flags +of every lemma, the element types and encoders of the container lemmas, the +field values and types of a document, and the environment the entry binds +are all stated, and an `rfl` is `Eq.refl` at the equation the binder states. +The well-typedness theorems of a recursive group are the group's recursor +(`T.rec` for each of its document types and `T.rec_j` of the block's first +type for the `j`-th container the kernel nests, in the order it nests them), +an induction hypothesis standing where the text recursed. The one core +backend renders the module to the Lean verification compiles, with `import` +lines and no `module` header while certificates A and B are Lean text (a +`module` cannot import them), and the verify record holds the module in the +authoring notation (§17.21.8), at the module's path with the extension +`.lex.tex`, which reads back to the data byte for byte; `preservation.json` +binds those bytes. A certificate held as data is audited row by row and +never as text: it imports only modules of the environment, declares only +safe theorems, definitions, and abbreviations, each pinning its axioms +exactly (the registry's for the library lemmas a row applies, the three +above for the composition), and names no forbidden constant in any +spelling; the audit module prints the axioms of every row of such a +certificate, and a row whose policy does not state what Lean prints is +`LLV7016`. `conformance_sp_14` builds every certificate E of the four +corpora this way, reads each record back to its data, verifies the +production example under the pinned Lean, and plants a wrong lemma, a changed +statement, a forged crate reference, and an added axiom, each refused. + **Evidence.** The conformance suite certifies every production root of `examples/production`, `examples/production-coverage`, `examples/models`, and `examples/reasoning`, and verification checks every example's certificates as part of its @@ -7377,6 +7406,7 @@ extract/.lean # when a production root exists extract/process.json # when a production root exists production/compiler-input.json # when a production root exists preserve/LexLeanPreserve/*/*.lean # when a production root exists +preserve/LexLeanPreserve/*/*/Compose/*.lex.tex # certificate E, as data (§17.17) preserve/program/R.json # when a production root exists preserve/crate/R..rs # when a production root exists preserve/audit.txt # when a production root exists @@ -8029,7 +8059,7 @@ pub fn verify_artifact(bundle: &Utf8Path) -> Result; **Run.** `build` refuses, before any Lean process runs and before anything is published: a malformed request (`LLC0201`); a root that is not a production root (`LLC0202`); an unregistered or undeclared target or another digest (`LLC0203`); a pin the project no longer matches (`LLC0204`); an evidence path that escapes the project or a symlinked bundle area (`LLS8001`); malformed evidence (`LLB6006`, `LLB6007`); evidence whose certificate is not the pinned one, earns a `refused` verdict, or is for a request whose reference program is not the root's lowered program (`LLV7101`); and a package the renderer refuses (`LLB6005`). Every check and eligibility failure of the project fails as it does for `check`. The project is then verified by the unchanged §22 pipeline over the entrypoint selection, so every production root of the project is certified; a project edited during the run is `LLC0204`. For each requested root and target, `build` renders the exporting package `verify` does not assemble (§17.17): the renderer of §17.16 over the verified lowered program, exporting the recorded entry alone as `run` with every parameter owned, with `sources` the semantic ID; its `src/lib.rs` begins with the certified crate's bytes. The bundle is published atomically, content-addressed, at `/production//`; there is no output-directory option. -**Bundle.** `result.json`; `packages///` with `Cargo.toml`, `src/lib.rs`, `provenance.json` (`lexlean/rust-provenance/1`), and `package.json` (the `lexlean/rust-package/1` manifest); and `evidence/`: `attestation.json`, `compiler-input.json`, `preservation.json`, `program/R.json`, `crate/R..rs`, `certificates/.lean` for certificates A, B, and E, and `gnaf/R/request.json` and `certificate.json` where evidence was offered. +**Bundle.** `result.json`; `packages///` with `Cargo.toml`, `src/lib.rs`, `provenance.json` (`lexlean/rust-provenance/1`), and `package.json` (the `lexlean/rust-package/1` manifest); and `evidence/`: `attestation.json`, `compiler-input.json`, `preservation.json`, `program/R.json`, `crate/R..rs`, `certificates/.lean` for certificates A and B and `certificates/.lex.tex` for certificate E (its kernel data in the authoring notation, §17.17), and `gnaf/R/request.json` and `certificate.json` where evidence was offered. **Result.** `lexlean/production-result/2` binds the compiler (its version, the language-1.2 compiler-semantics ID of §21.2, read as an opaque digest, and the Lean toolchain); the source, semantic, and lock identities; the build and attestation IDs and the attestation, compiler input (whose SHA-256 is the compiler-input ID, §22.10), and preservation record; and per root its index `R`, program, and optimality, and per target the target ID and digest, the package's name, version, directory, export, and files, the crate, the entry, the certification, and the effects the output's realization can exhibit on its target, ascending and exactly those that eligibility requires of the root there (§17.13); an output with `recursion` recurses to a depth bounded only by its input, so the host must give the call a stack that depth fits, and exhausting it aborts the process. `lexlean production build` reports how many outputs need such a stack. Every file is stated by bundle-relative path, byte length, and SHA-256. The certification status is the closed `kernel-checked`: certificates A, B, and E compiled silently under the pinned Lean, replayed through `leanchecker`, and their root theorems depend on exactly the stated axioms (§17.17). It is preservation, at level `build`, and never optimality. Optimality is `not-claimed`, or `gnaf` with the certificate identity, the universe identity, the two documents, and the verdict the host checker of §17.18 recomputes, `certified` or `incomplete`; a `refused` verdict is never recorded. `result_id` is SHA-256 over `"lexlean-production-result-v1"` and `frame("result-body", canonical_json(result without result_id))`. The result holds no absolute path, environment value, or time; because it binds the attestation, which records the host and executable hashes (§22.9), it is identical across project locations and working directories on one host and toolchain, not across hosts. @@ -9269,6 +9299,7 @@ Every row below is normative, has honesty level `build`, and MUST be copied byte | `SP-11` | `preservation` | Every production root of examples/production, examples/production-coverage, examples/models, and examples/reasoning is rendered in each of its targets as a package that builds under the pinned Rust toolchain, and on the seeded inputs of the differential, through the root and through its boundary entry on valid and invalid inputs, the printed outcome of each package equals the interpreter's outcome, which the declared Rust machine reproduces; that the compiler agrees with the machine the certificates are about is build evidence, never a premise of a proof. | §17.16, §17.17 | | `SP-12` | `preservation` | The preservation library is LexLean source: every module of its registry is one language-1.2 native core module, the library project holds no file of Lean source, and no Lean file anywhere in the release tree declares its namespace or lies under its module root; the registry lists only the modules, and the declarations, their exact axiom policies, the constructors of the correspondence, and the cases of its soundness theorem are read from the native data, which the compiler embeds, hashes into the language-1.2 semantics, and generates the Lean of every verification from. The one Lean text a generated library module carries beside its data is the decoder of core module 2, which loads native modules. | §17.17 | | `SP-13` | `preservation` | Certificate text writes every list and array of any length as a term the pinned Lean elaborates without binders: one of at most 32 elements as a literal and a longer one as a chain of List.cons, so that no certificate holds a literal Lean splits under let binders; a root calling a function of 33 parameters with 33 operands, a root copying a record of 33 fields, and a root matching on 33 constructors of one field each verify through the whole pipeline, and none of their certificates writes a literal of more than 32 elements. | §17.17 | +| `SP-14` | `preservation` | Certificate E of every production root is kernel-term data: a native core module of schema lexlean/core-module/2 that the compiler builds from the lowered program, the layout, and the recorded types of the preservation library's lemmas, every argument and universe level explicit, which the one core backend renders to the Lean that verification compiles and whose record is the authoring notation, reading back to the data byte for byte; its theorems state what §17.17 states for the composition, each row pins its axioms exactly and the audit module prints and checks them, a certificate held as data is audited row by row and never as text (no axiom row, no forbidden constant, imports within the environment), and a planted wrong lemma, a changed statement, a forged crate reference, or an added axiom is refused. | §17.17 | | `MD-01` | `models` | Language 1.2 artifact, contract, realization, evidence, and model declarations, the checked_apply term, the contract_violation type, and the less_than primitive belong to the closed lexlean/semantic-module/2 schema and its snapshot schema, are rejected under language 1.1 before either backend runs, and admit no member outside the closed schema, such as prompt text, a free-form description, or raw model configuration. | §17.12 | | `MD-02` | `models` | A model artifact is admitted only from a configured, content-addressed, confined project file whose SHA-256 and byte length equal its declaration and whose bytes decode under its declared closed schema to its declared type and role; a missing artifact or a digest or length mismatch fails with LLR3007, a schema, type, or role violation fails with LLR3008, and the generated Lean embeds the exact bytes with a kernel-checked theorem that the typed value is their decoding. | §17.12, §10.1, §26.3 | | `MD-03` | `models` | A contract names typed input, output, and optional state interfaces and prior proposition-valued predicates of exactly those interface signatures, and each runtime validator is an executable Boolean definition of the same signature linked to its predicate by a statement-exact soundness theorem and an optional completeness theorem that Lean restates against the fixed model semantics; any mismatch fails with LLT4006. | §17.12 | @@ -9345,7 +9376,7 @@ Every row below is normative, has honesty level `build`, and MUST be copied byte | `RT-03` | `runtime` | A verification compiles every runtime module that a project's generated modules, or the calculus modules its certificates are checked against, import before the project's modules, replays it with `leanchecker`, and audits each of its declarations against the axioms its row pins; the committed verification of a project that uses the collections prints them, the runtime's own project verifies under the pinned Lean, and a row that pins another axiom set than its declaration observes fails with LLV7005. | §17.12, §22.3, §22.5, §22.6 | | `RT-04` | `runtime` | No Lean runtime text remains in the language-1.2 compiler: a generated language-1.2 module imports the runtime modules whose constants it names and declares nothing under a runtime namespace, and the only Lean runtime text in the compiler's source outside unit-test items, in one string literal or in several written together, is the decoder of core module 2, which loads native modules and so cannot be one; a runtime text planted in any of its shapes, raw or escaped, with or without a namespace line, split across literals, or after a test module, is found. | §17.12, §18.1 | -**Total required capability IDs:** 391. +**Total required capability IDs:** 392. No row may be downgraded to `some-true` or `open`. Upstream Lean facts are ledger/authority rows, not substitutions for these build behaviors. diff --git a/VERIFICATION.md b/VERIFICATION.md index a0d3130c8..2190980d7 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -1361,6 +1361,75 @@ carries the header of the lifted budgets), and the derivation bound of after: the chain is shorter than the literal Lean splits under binders, and the root still exceeds `max_file_bytes` in phase certificates, `LLS8002`). +### certificate E is kernel-term data and a defect in it is refused + +Certificate E of a root is a native core module the compiler builds +(`production/certificate/data.rs` over `production/kernel.rs`), so a defect is +planted in the data and must be seen where the kernel checks it, or before, +where the data is audited. `conformance_sp_14` builds every certificate E of the +four corpora as data, reads each record back from its notation, verifies the +production example under the pinned Lean, and then plants five defects in the +data of one certificate E of that example, each refused. The plants below are +what the case runs; their outputs were recorded on Linux x86-64 with Lean +4.32.1. Command: `cargo test -p repo-conformance --test conformance -- +conformance_sp_14 --nocapture`. + +Planted (a), a wrong lemma: the first scalar well-typedness lemma the +certificate applies (`LexLeanPreservation.Rust.wt_u32`, the proof that the +encoded first argument `left : UInt32` is well typed) renamed to `LexLeanPreservation.Rust.wt_bool` in every constant node +that names it. Expected: the kernel refuses the row, since the lemma's type is +not the argument's. + +```text +/src/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCorePlantWrongLemma.lean:517:0: error: native core declaration 'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root': + (kernel) application type mismatch + LexLeanPreservation.Rust.wt_bool left +``` + +Planted (b), a changed statement: the constant node of the fallibility flag +(`Bool.true`, shared by the statement and the proof) renamed to `Bool.false`. +Expected: the restated theorem claims the other result shape of the crate's +root, and `compose`'s equation on `fnFallible` no longer holds by `Eq.refl`. + +```text +/src/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCorePlantChangedStatement.lean:517:0: error: native core declaration 'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root': + (kernel) application type mismatch + LexLeanPreservation.Rust.compose (fun __e_n => RustCore.root __e_n 0) +``` + +Planted (c), a forged crate reference: the constant node `.krate` +renamed to `.flags`. Expected: the kernel refuses the row, since +certificate B's root theorem is about the crate, not the flags. + +```text +/src/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCorePlantForgedCrate.lean:517:0: error: native core declaration 'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root': + (kernel) application type mismatch + LexLeanPreservation.Rust.RCI RustCore.flags +``` + +Planted (d), an added axiom: a constant node `sorryAx` appended to the DAG and +made the `root` row's proof. Expected: the data audit refuses the module +before any Lean runs, naming the forbidden constant. + +```text +the forbidden constant `sorryAx` +``` + +Planted (e), a lying policy: the `root` row's policy changed from the three +certificate axioms to `exact{axioms: []}`. Expected: Lean accepts the module +(the proof is unchanged), and the audit module, which prints the axioms of +every row of a data certificate, refuses the row whose policy does not state +what Lean prints. + +```text +the certificate row `LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root` depends on ["Classical.choice", "Quot.sound", "propext"], its policy pins [] +``` + +Removed: the plants are mutations of a clone of the generated data inside the +case; nothing is restored. The case passes on the unplanted data, and the +committed records of the four corpora are its notation, read back to the data +byte for byte. + ### certificate generation is bounded `lexlean verify` of a project whose root instantiates the generic chain diff --git a/crates/conformance/src/cases/preservation.rs b/crates/conformance/src/cases/preservation.rs index 22bd89979..de8497958 100644 --- a/crates/conformance/src/cases/preservation.rs +++ b/crates/conformance/src/cases/preservation.rs @@ -921,6 +921,10 @@ fn assert_statement( rendering: &lexlean::production::certificate::Certificate, composed: &lexlean::production::certificate::Certificate, ) { + if let Some(data) = &composed.data { + assert_data_statement(name, entry, rendering, composed, data); + return; + } let at = composed .text .find("theorem root ") @@ -1029,6 +1033,380 @@ fn assert_statement( ); } +/// The namespaces a certificate begins names with: from its constant nodes +/// when it is held as data (every constant of kernel data is a resolved +/// name), else from its text. +fn referenced_namespaces_in( + certificate: &lexlean::production::certificate::Certificate, + user: &BTreeSet, +) -> BTreeSet { + match &certificate.data { + Some(data) => data + .nodes + .iter() + .filter_map(|node| match node { + lexlean::ir::core::CoreNode::Const { n, .. } => { + let first = n.split('.').next()?; + (n.contains('.') + && !user.contains(first) + && !lexlean::ir::semantic::is_backend_bare_name(first)) + .then(|| first.to_owned()) + } + _ => None, + }) + .collect(), + None => referenced_namespaces(&certificate.text, user), + } +} + +/// No name of a certificate can be captured by a parameter: in kernel data a +/// constant is a resolved name and a variable an index, so there is nothing +/// to check; a text certificate is checked lexeme by lexeme. +fn assert_no_bare_globals_in( + certificate: &lexlean::production::certificate::Certificate, + user: &BTreeSet, + prefix_root: &str, +) { + if certificate.data.is_none() { + assert_no_bare_globals(&certificate.module, &certificate.text, user, prefix_root); + } +} + +/// The end-to-end theorem a certificate E held as data states, read off its +/// `root` row: the root's parameters then `__e_hrep : RepresentableL [enc xᵢ]` +/// as binders, and the conclusion of §17.17 for the root or its entry, with +/// certificate A's observation, certificate B's crate, the fallibility flag, +/// and the function the entry is (SP-09, SP-14). Every binder the composition +/// adds begins with two underscores. +fn assert_data_statement( + name: &str, + entry: &preservation::Certified, + rendering: &lexlean::production::certificate::Certificate, + composed: &lexlean::production::certificate::Certificate, + data: &lexlean::ir::core::CoreModule, +) { + use lexlean::ir::core::CoreNode; + let module = &composed.module; + let row = data + .declarations + .iter() + .find(|row| row.name == composed.theorem) + .unwrap_or_else(|| panic!("{name}: `{module}` states no root theorem")); + assert_eq!( + data.declarations + .iter() + .filter(|row| row.name.ends_with(".root")) + .count(), + 1, + "{name}: `{module}` states one root theorem" + ); + let node = |index: usize| &data.nodes[index]; + let spine = |mut index: usize| -> (usize, Vec) { + let mut args = Vec::new(); + while let CoreNode::App { f, x } = node(index) { + args.push(*x); + index = *f; + } + args.reverse(); + (index, args) + }; + let is_const = |index: usize, expected: &str| matches!(node(index), CoreNode::Const { n, .. } if n == expected); + let applied = |index: usize, head: &str, arity: usize| -> Vec { + let (f, args) = spine(index); + assert!( + is_const(f, head) && args.len() == arity, + "{name}: `{module}`: expected `{head}` applied to {arity} arguments, found {:?} to {}", + node(f), + args.len() + ); + args + }; + // The binders. + let parameters = &entry.program.functions[0].parameters; + let mut binders = Vec::new(); + let mut body = row.r#type; + while let CoreNode::Forall { n, t, v, .. } = node(body) { + binders.push((n.clone(), *t)); + body = *v; + } + assert_eq!( + binders.len(), + parameters.len() + 1, + "{name}: `{module}` binds the {} parameters and one hypothesis", + parameters.len() + ); + let (hypothesis, own) = binders.split_last().expect("a hypothesis"); + assert_eq!( + hypothesis.0, "__e_hrep", + "{name}: `{module}`: the hypothesis binder" + ); + for (binder, _) in own { + assert!( + !binder.starts_with("__"), + "{name}: `{module}` binds the parameter `{binder}` under a generated name" + ); + } + // The hypothesis: RepresentableL of the encodings, each applied to its + // parameter, the i-th of n parameters being #(n - 1 - i) under them. + let list = applied(hypothesis.1, "LexLeanPreservation.Rust.RepresentableL", 1)[0]; + let encodings = list_items(data, list); + assert_eq!( + encodings.len(), + own.len(), + "{name}: `{module}`: one encoding per parameter" + ); + for (position, encoding) in encodings.iter().enumerate() { + let (_, args) = spine(*encoding); + let last = *args + .last() + .unwrap_or_else(|| panic!("{name}: `{module}`: an encoding applies to its parameter")); + assert!( + matches!(node(last), CoreNode::BVar { i } if *i == own.len() - 1 - position), + "{name}: `{module}`: encoding {position} does not encode parameter {position}" + ); + } + // The conclusion: ∃ __e_ro, … + let exists = applied(body, "Exists", 2); + assert!( + is_const(exists[0], "LexLeanPreservation.Rust.ROut"), + "{name}: `{module}`: the witness is an outcome" + ); + let (witness, conjunction) = match node(exists[1]) { + CoreNode::Lambda { n, v, .. } => (n.clone(), *v), + other => panic!("{name}: `{module}`: the predicate is not a lambda: {other:?}"), + }; + assert_eq!(witness, "__e_ro", "{name}: `{module}`: the witness binder"); + let fallible = lexlean::calculus::rust::fallible_functions(&entry.program) + .expect("a valid program")[entry.entry as usize]; + let flag = if fallible { "Bool.true" } else { "Bool.false" }; + let a = &entry.certificate.module; + let b = &rendering.module; + // Under __e_ro, the encodings list of the hypothesis is lifted by one: + // the arguments of RCI are the encodings applied to #(n - i), checked as + // a list of the same length whose heads are the same encoders. + let check_args = |list_node: usize| { + let items = list_items(data, list_node); + assert_eq!( + items.len(), + own.len(), + "{name}: `{module}`: RCI takes one encoding per parameter" + ); + for (position, item) in items.iter().enumerate() { + let (_, args) = spine(*item); + let last = *args.last().expect("an applied encoding"); + assert!( + matches!(node(last), CoreNode::BVar { i } if *i == own.len() - position + 1), + "{name}: `{module}`: RCI's argument {position} is not the encoding of parameter {position}" + ); + } + }; + let check_rci = |rci: usize, function: u64| { + let args = applied(rci, "LexLeanPreservation.Rust.RCI", 4); + assert!( + is_const(args[0], &format!("{b}.krate")), + "{name}: `{module}`: RCI is about certificate B's crate" + ); + let ident = applied(args[1], "LexLeanPreservation.Rust.fnIdent", 1); + assert!( + matches!(node(ident[0]), CoreNode::Nat { v } if *v == function.to_string()), + "{name}: `{module}`: RCI invokes function {function}" + ); + check_args(args[2]); + assert!( + matches!(node(args[3]), CoreNode::BVar { i: 0 }), + "{name}: `{module}`: RCI ends in the witness" + ); + }; + let check_realizes = |realizes: usize, observation: &dyn Fn(usize)| { + let args = applied(realizes, "LexLeanPreservation.Rust.RealizesFn", 3); + assert!( + is_const(args[0], flag), + "{name}: `{module}`: the fallibility flag is `{flag}`" + ); + observation(args[1]); + assert!( + matches!(node(args[2]), CoreNode::BVar { i: 0 }), + "{name}: `{module}`: RealizesFn ends in the witness" + ); + }; + let denote_of = |observation: usize, depth: usize| { + let (f, args) = spine(observation); + assert!( + is_const(f, &format!("{a}.denote")), + "{name}: `{module}`: the observation is certificate A's `denote`" + ); + assert_eq!( + args.len(), + own.len(), + "{name}: `{module}`: `denote` takes the parameters" + ); + for (position, arg) in args.iter().enumerate() { + assert!( + matches!(node(*arg), CoreNode::BVar { i } if *i == own.len() - 1 - position + depth), + "{name}: `{module}`: `denote`'s argument {position} is parameter {position}" + ); + } + }; + if entry.entry == 0 { + let both = applied(conjunction, "And", 2); + check_realizes(both[0], &|observation| denote_of(observation, 2)); + check_rci(both[1], 0); + } else { + let both = applied(conjunction, "And", 2); + check_rci(both[0], entry.entry); + let tail = applied(both[1], "And", 2); + // (accepts xs → RealizesFn F (someObs (denote xs)) ro) ∧ (¬ accepts xs → RealizesFn F (Obs.value Value.none) ro) + let (accepts_ty, accepted) = match node(tail[0]) { + CoreNode::Forall { t, v, .. } => (*t, *v), + other => { + panic!("{name}: `{module}`: the accepted case is not an implication: {other:?}") + } + }; + let (f, _) = spine(accepts_ty); + assert!( + is_const(f, &format!("{a}.accepts")), + "{name}: `{module}`: the hypothesis of the accepted case is `accepts`" + ); + check_realizes_at( + data, + accepted, + flag, + 1, + &|observation| { + let inner = applied(observation, "LexLeanPreservation.someObs", 1); + denote_of(inner[0], 3); + }, + name, + module, + ); + let (refuses_ty, refused) = match node(tail[1]) { + CoreNode::Forall { t, v, .. } => (*t, *v), + other => { + panic!("{name}: `{module}`: the refused case is not an implication: {other:?}") + } + }; + let not = applied(refuses_ty, "Not", 1); + let (f, _) = spine(not[0]); + assert!( + is_const(f, &format!("{a}.accepts")), + "{name}: `{module}`: the refused case negates `accepts`" + ); + check_realizes_at( + data, + refused, + flag, + 1, + &|observation| { + let value = applied(observation, "LexLeanPreservation.Obs.value", 1); + assert!( + is_const(value[0], "LexLeanTarget.TargetSyntax.Value.none"), + "{name}: `{module}`: a refused entry returns none" + ); + }, + name, + module, + ); + } + // No binder the composition adds is a name a parameter could be. + let own_names: BTreeSet<&str> = own.iter().map(|(binder, _)| binder.as_str()).collect(); + for index in reachable(data, row.r#type) + .into_iter() + .chain(reachable(data, row.value.expect("a proof"))) + { + if let CoreNode::Lambda { n, .. } | CoreNode::Forall { n, .. } = node(index) { + assert!( + n.is_empty() || n == "_" || n.starts_with("__") || own_names.contains(n.as_str()), + "{name}: `{module}` binds `{n}`, which a parameter of that name would capture" + ); + } + } +} + +/// `RealizesFn flag observation #witness` where the witness is `#witness` +/// under the binders between it and the application. +fn check_realizes_at( + data: &lexlean::ir::core::CoreModule, + realizes: usize, + flag: &str, + witness: usize, + observation: &dyn Fn(usize), + name: &str, + module: &str, +) { + use lexlean::ir::core::CoreNode; + let mut args = Vec::new(); + let mut index = realizes; + while let CoreNode::App { f, x } = &data.nodes[index] { + args.push(*x); + index = *f; + } + args.reverse(); + assert!( + matches!(&data.nodes[index], CoreNode::Const { n, .. } if n == "LexLeanPreservation.Rust.RealizesFn") + && args.len() == 3, + "{name}: `{module}`: a RealizesFn statement" + ); + assert!( + matches!(&data.nodes[args[0]], CoreNode::Const { n, .. } if n == flag), + "{name}: `{module}`: the fallibility flag is `{flag}`" + ); + observation(args[1]); + assert!( + matches!(&data.nodes[args[2]], CoreNode::BVar { i } if *i == witness), + "{name}: `{module}`: RealizesFn ends in the witness" + ); +} + +/// The items of a `List.cons`/`List.nil` literal node. +fn list_items(data: &lexlean::ir::core::CoreModule, mut list: usize) -> Vec { + use lexlean::ir::core::CoreNode; + let mut out = Vec::new(); + loop { + let mut args = Vec::new(); + let mut index = list; + while let CoreNode::App { f, x } = &data.nodes[index] { + args.push(*x); + index = *f; + } + args.reverse(); + match &data.nodes[index] { + CoreNode::Const { n, .. } if n == "List.cons" && args.len() == 3 => { + out.push(args[1]); + list = args[2]; + } + CoreNode::Const { n, .. } if n == "List.nil" && args.len() == 1 => return out, + other => panic!("not a list literal: {other:?}"), + } + } +} + +/// Every node reachable from `root`. +fn reachable(data: &lexlean::ir::core::CoreModule, root: usize) -> Vec { + use lexlean::ir::core::CoreNode; + let mut seen = vec![false; data.nodes.len()]; + let mut stack = vec![root]; + let mut out = Vec::new(); + while let Some(index) = stack.pop() { + if seen[index] { + continue; + } + seen[index] = true; + out.push(index); + match &data.nodes[index] { + CoreNode::App { f, x } => stack.extend([*f, *x]), + CoreNode::Lambda { t, v, .. } | CoreNode::Forall { t, v, .. } => stack.extend([*t, *v]), + CoreNode::Let { t, v, body, .. } => stack.extend([*t, *v, *body]), + CoreNode::Mdata { x, .. } | CoreNode::Projection { x, .. } => stack.push(*x), + CoreNode::BVar { .. } + | CoreNode::Sort { .. } + | CoreNode::Const { .. } + | CoreNode::Nat { .. } + | CoreNode::String { .. } => {} + } + } + out +} + /// Certifying the projects takes minutes; the cases share one run, and the /// projects are certified side by side: each waits most of its time on one /// Lean process at a time and holds about two gigabytes, so four of them keep @@ -1860,22 +2238,38 @@ pub fn run(id: &str) { rendering["entry"]["symbol"].as_str(), Some(format!("f{function}").as_str()) ); + // Certificate E is kernel-term data, recorded in the + // authoring notation (SP-14). let composed = std::fs::read_to_string( - base.join(lexlean::production::preserve::module_path( + base.join(lexlean::production::preserve::notation_path( rendering["composed"]["module"].as_str().expect("a module"), )) .as_std_path(), ) .expect("the published certificate E"); - let invoked: BTreeSet = composed - .match_indices("Rust.fnIdent ") - .map(|(at, found)| { - composed[at + found.len()..] - .chars() - .take_while(char::is_ascii_digit) - .collect::() - .parse() - .expect("a function number") + // The record is kernel data: the function E states is the + // argument of every `fnIdent` node, and an entry is stated + // through its `entry_accepts` theorem. + let data: lexlean::ir::core::CoreModule = serde_json::from_value( + lexlean::sdk::read_module(&composed).expect("the record reads"), + ) + .expect("the record is a core module"); + let invoked: BTreeSet = data + .nodes + .iter() + .filter_map(|node| match node { + lexlean::ir::core::CoreNode::App { f, x } => { + match (&data.nodes[*f], &data.nodes[*x]) { + ( + lexlean::ir::core::CoreNode::Const { n, .. }, + lexlean::ir::core::CoreNode::Nat { v }, + ) if n == "LexLeanPreservation.Rust.fnIdent" => { + Some(v.parse().expect("a function number")) + } + _ => None, + } + } + _ => None, }) .collect(); assert_eq!( @@ -1883,8 +2277,11 @@ pub fn run(id: &str) { BTreeSet::from([function]), "{example} R{index} {target}: E states the function the record names" ); + let has_entry = data.nodes.iter().any(|node| { + matches!(node, lexlean::ir::core::CoreNode::Const { n, .. } if n.ends_with(".entry_accepts")) + }); assert_eq!( - composed.contains("entry_accepts"), + has_entry, function != 0, "{example} R{index} {target}: E has an entry exactly when the record names one" ); @@ -1971,13 +2368,17 @@ pub fn run(id: &str) { // Certificates B and E of each target are published and bound // the same way. for rendering in row["renderings"].as_array().expect("renderings") { - for bound in [rendering, &rendering["composed"]] { + for (bound, as_data) in [(rendering, false), (&rendering["composed"], true)] + { let module = bound["module"].as_str().expect("a module"); - let text = std::fs::read( - root.join("preserve") - .join(lexlean::production::preserve::module_path(module)), - ) - .expect("the published certificate"); + // Certificate E is recorded in the authoring notation. + let path = if as_data { + lexlean::production::preserve::notation_path(module) + } else { + lexlean::production::preserve::module_path(module) + }; + let text = std::fs::read(root.join("preserve").join(path)) + .expect("the published certificate"); assert_eq!( bound["sha256"].as_str(), Some( @@ -2817,7 +3218,7 @@ pub fn run(id: &str) { referenced.extend(referenced_namespaces(&rendering.text, &users)); } for (_, composed) in &entry.composed { - referenced.extend(referenced_namespaces(&composed.text, &users)); + referenced.extend(referenced_namespaces_in(composed, &users)); } } } @@ -2854,12 +3255,7 @@ pub fn run(id: &str) { &named_root, ); for (_, composed) in &entry.composed { - assert_no_bare_globals( - &composed.module, - &composed.text, - &named_users, - &named_root, - ); + assert_no_bare_globals_in(composed, &named_users, &named_root); } } for entry in &named { @@ -2907,14 +3303,13 @@ pub fn run(id: &str) { // representable, and the conclusion is the two // statements of §17.17 and nothing else. assert_statement(name, &entry, rendering, composed); - assert_no_bare_globals(&composed.module, &composed.text, &users, &root); + assert_no_bare_globals_in(composed, &users, &root); for mutation in preservation::CompositionMutation::ALL { - let places = mutation.places(&composed.text); + let places = mutation.places_in(composed); assert!(places > 0, "{mutation:?} applies to `{}`", composed.module); for nth in 0..places { - let planted = mutation - .plant(&composed.text, nth) - .expect("a counted place"); + let planted = + mutation.plant_in(composed, nth).expect("a counted place"); assert_ne!(planted, composed.text, "{mutation:?} {nth}"); } } @@ -3033,6 +3428,309 @@ pub fn run(id: &str) { "withheld collection roots are reported: {missing:?}" ); } + // §17.17: certificate E is kernel-term data, recorded in the notation. + "SP-14" => { + // Every certificate E of the four corpora is built as a core + // module: the record reads back to the data byte for byte, the + // data audit admits it, and every row pins its axioms exactly. + let mut built = 0usize; + let mut notation_bytes = 0usize; + let mut failures: Vec = Vec::new(); + for (name, project) in certified_projects() { + let checked = support::checked_project(&project); + let limits = support::limits(&project); + let linked = linked_modules(&checked); + let hex = checked.semantic_id.to_hex()[..32].to_owned(); + for (index, root) in roots(&checked).expect("the reports").iter().enumerate() { + let lowered = + lower_root(&linked, &root.module, &root.name, root.report, &limits) + .expect("the root lowers"); + let module = format!("LexLeanPreserve.C{hex}.R{index}"); + let fallible = lexlean::calculus::rust::fallible_functions(&lowered.program) + .expect("the fallible functions")[lowered.entry() as usize]; + for row in &root.report.targets { + let module_b = + lexlean::production::rust_cert::module_for(&module, &row.target) + .expect("a Rust target"); + let module_e = lexlean::production::rust_cert::module_for( + &format!("{module}.Compose"), + &row.target, + ) + .expect("a Rust target"); + let composed = lexlean::production::certificate::certificate_e( + &linked, + &root.module, + &root.name, + &lowered, + &module, + &module_b, + &module_e, + fallible, + limits.max_file_bytes, + ); + let certificate = match composed { + Ok(certificate) => certificate, + Err(diagnostic) => { + failures.push(format!( + "{name} R{index} {}: {}", + row.target, diagnostic.message + )); + continue; + } + }; + let data = certificate.data.as_ref().expect("certificate E is data"); + let source = certificate + .source + .as_ref() + .expect("certificate E is recorded in the notation"); + let read = lexlean::sdk::read_module(source).expect("the record reads"); + let canonical = serde_json::to_value(data).expect("the data is JSON"); + assert_eq!( + read, canonical, + "{module_e}: the record reads back to the data" + ); + let environment: BTreeSet = [ + module.clone(), + module_b.clone(), + "LexLeanPreservation.Compose".to_owned(), + ] + .into_iter() + .collect(); + preserve::audit_core(data, &environment).expect("the data audit admits it"); + for declaration in &data.declarations { + assert!( + matches!( + declaration.policy, + lexlean::ir::core::CoreAxiomPolicy::Exact(_) + ), + "{module_e}: `{}` pins its axioms exactly", + declaration.name + ); + } + built += 1; + notation_bytes += source.len(); + } + } + } + eprintln!( + "SP-14: {built} certificates E built as data, {notation_bytes} bytes of notation" + ); + assert!( + failures.is_empty(), + "every certificate E is built as data:\n{}", + failures.join("\n") + ); + // The committed records hold every certificate E in the notation. + for (name, _) in certified_projects() { + let base = repo_root() + .join("examples") + .join(name) + .join("expected/verify/preserve"); + let record: serde_json::Value = serde_json::from_slice( + &std::fs::read(base.join("preservation.json").as_std_path()) + .expect("a committed record"), + ) + .expect("the record is JSON"); + for row in record["roots"].as_array().expect("roots") { + for rendering in row["renderings"].as_array().expect("renderings") { + let module = rendering["composed"]["module"].as_str().expect("a module"); + let path = base.join(preserve::notation_path(module)); + assert!( + path.as_std_path().is_file(), + "{name}: certificate E `{module}` is recorded in the notation at {path}" + ); + } + } + } + if !support::lean_backed("SP-14") { + return; + } + // The production example, certified end to end with every + // certificate E as data: every module compiles, replays, and the + // audit sees exactly the axioms each row pins. + let project = P::copy_example("production"); + let certified = preservation::certificates(&project); + let workspace = preservation::staged(&project, &certified); + let root = tempfile::Builder::new() + .prefix("lexlean-sp14-") + .tempdir() + .expect("tempdir"); + let checked = preservation::check(&workspace, root.path()); + assert!( + checked.failure.is_none(), + "every certificate as data verifies under the pinned Lean: {:?}", + checked.failure + ); + let all: Vec = certified + .iter() + .flat_map(preservation::Certified::all) + .collect(); + audit(&checked.audit_output, &all).expect("the audit, every row's axioms included"); + // Four plants in the data of one certificate E, each refused: a + // wrong lemma, a changed statement, a forged crate reference, and + // an added axiom (refused before Lean by the data audit, and, as + // a lying policy, by the audit module). + let (target, composed) = &certified[0].composed[0]; + let module_b = lexlean::production::rust_cert::module_for( + &certified[0].certificate.module, + target, + ) + .expect("a Rust target"); + let data = composed.data.as_ref().expect("certificate E is data"); + let rename = |data: &lexlean::ir::core::CoreModule, from: &str, to: &str| { + let mut planted = data.clone(); + let mut renamed = 0; + for node in &mut planted.nodes { + if let lexlean::ir::core::CoreNode::Const { n, .. } = node { + if n == from { + *n = to.to_owned(); + renamed += 1; + } + } + } + assert!(renamed > 0, "the plant renames `{from}`"); + planted + }; + let refused = |label: &str, planted: &lexlean::ir::core::CoreModule| { + let module = format!("{}Plant{label}", composed.module); + let text = lexlean::backend::core::lean_text_legacy(planted, &module) + .expect("the planted module renders"); + let output = preservation::compile_text(root.path(), &module, &text); + let joined = format!( + "{}{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + assert!( + !output.status.success() && joined.contains("error"), + "{label}: the planted certificate E is refused by Lean: {joined}" + ); + // The first error, with the kernel's reason on the lines after it. + joined.lines().take(3).collect::>().join( + " + ", + ) + }; + let scalar = data + .nodes + .iter() + .find_map(|node| match node { + lexlean::ir::core::CoreNode::Const { n, .. } + if n.starts_with("LexLeanPreservation.Rust.wt_") + && !n.ends_with("wt_bool") => + { + Some(n.clone()) + } + _ => None, + }) + .expect("a scalar well-typedness lemma"); + let wrong_lemma = refused( + "WrongLemma", + &rename(data, &scalar, "LexLeanPreservation.Rust.wt_bool"), + ); + let flag = if data.nodes.iter().any(|node| { + matches!(node, lexlean::ir::core::CoreNode::Const { n, .. } if n == "Bool.true") + }) { + ("Bool.true", "Bool.false") + } else { + ("Bool.false", "Bool.true") + }; + let changed_statement = refused("ChangedStatement", &rename(data, flag.0, flag.1)); + let forged_crate = refused( + "ForgedCrate", + &rename( + data, + &format!("{module_b}.krate"), + &format!("{module_b}.flags"), + ), + ); + // An added axiom: `sorryAx` as the root's proof is refused by the + // data audit before any Lean runs. + let mut with_axiom = data.clone(); + with_axiom.nodes.push(lexlean::ir::core::CoreNode::Const { + n: "sorryAx".to_owned(), + u: vec![lexlean::ir::core::CoreLevel::Zero], + }); + let last = with_axiom.nodes.len() - 1; + for row in &mut with_axiom.declarations { + if row.name == composed.theorem { + row.value = Some(last); + } + } + let environment: BTreeSet = workspace + .files + .iter() + .map(|file| file.module.clone()) + .collect(); + let audit_refusal = preserve::audit_core(&with_axiom, &environment) + .expect_err("the data audit refuses the added axiom"); + assert!( + audit_refusal.contains("sorryAx"), + "the data audit names the forbidden constant: {audit_refusal}" + ); + // A row whose policy lies about its axioms compiles, and the audit + // module refuses it: the policies are checked, not trusted. + let mut lying = data.clone(); + for row in &mut lying.declarations { + if row.name == composed.theorem { + row.policy = lexlean::ir::core::CoreAxiomPolicy::Exact(Vec::new()); + } + } + let mut lying_certificate = composed.clone(); + lying_certificate.module = format!("{}PlantLyingPolicy", composed.module); + lying_certificate.text = + lexlean::backend::core::lean_text_legacy(&lying, &lying_certificate.module) + .expect("the planted module renders"); + lying_certificate.data = Some(lying); + let output = preservation::compile_text( + root.path(), + &lying_certificate.module, + &lying_certificate.text, + ); + assert!( + output.status.success(), + "a lying policy is not Lean's to refuse: {}", + String::from_utf8_lossy(&output.stderr) + ); + let rendered = support::rendered(&project); + let user: Vec<(String, String)> = rendered + .modules + .iter() + .map(|module| (module.lean_module.clone(), module.lean_text.clone())) + .collect(); + // The planted E is staged after the A and B it imports, as the + // root's certificates are. + let mut planted_set = vec![certified[0].certificate.clone()]; + planted_set.extend( + certified[0] + .renderings + .iter() + .filter(|(rendered_target, _)| rendered_target == target) + .map(|(_, b)| b.clone()), + ); + planted_set.push(lying_certificate.clone()); + let planted_workspace = + preserve::workspace(&user, &planted_set).expect("the planted workspace stages"); + let audit_output = preservation::compile_text( + root.path(), + &format!("{}Plant", preserve::AUDIT_MODULE), + &planted_workspace.audit.text, + ); + let audit_text = format!( + "{}{}", + String::from_utf8_lossy(&audit_output.stdout), + String::from_utf8_lossy(&audit_output.stderr) + ); + let lying_policy = audit(&audit_text, std::slice::from_ref(&lying_certificate)) + .expect_err("the audit refuses a row whose policy lies"); + assert!( + lying_policy.contains("its policy pins"), + "the audit names the lying row: {lying_policy}" + ); + eprintln!( + "SP-14 plants refused:\n wrong lemma: {wrong_lemma}\n changed statement: {changed_statement}\n forged crate: {forged_crate}\n added axiom: {audit_refusal}\n lying policy: {lying_policy}" + ); + } _ => panic!("no preservation case is wired for {id}"), } } diff --git a/crates/conformance/src/cases/repository.rs b/crates/conformance/src/cases/repository.rs index 1face755c..974c44981 100644 --- a/crates/conformance/src/cases/repository.rs +++ b/crates/conformance/src/cases/repository.rs @@ -411,7 +411,7 @@ pub(crate) fn run(id: &str) { let model = repo_model::Model::load(&root.join("model").into_std_path_buf()) .expect("the model loads"); let table = spec_table(); - assert_eq!(table.len(), 391, "§31 has 391 rows"); + assert_eq!(table.len(), 392, "§31 has 392 rows"); assert_eq!(model.ids.id.len(), table.len(), "register row count"); for ((spec_id, spec_suite, spec_statement), row) in table.iter().zip(model.ids.id.iter()) diff --git a/crates/conformance/src/cases/verification.rs b/crates/conformance/src/cases/verification.rs index 446964092..f33ed6283 100644 --- a/crates/conformance/src/cases/verification.rs +++ b/crates/conformance/src/cases/verification.rs @@ -788,6 +788,15 @@ pub(crate) fn run(id: &str) { f.starts_with("preserve/LexLeanPreserve/") && f.ends_with(".lean") }), ), + ( + // Certificate E, held as kernel data (§17.17). + "preserve/LexLeanPreserve/*/*/Compose/*.lex.tex", + Box::new(|f: &str| { + f.starts_with("preserve/LexLeanPreserve/") + && f.contains("/Compose/") + && f.ends_with(".lex.tex") + }), + ), ( "preserve/program/R.json", Box::new(|f: &str| f.starts_with("preserve/program/R") && f.ends_with(".json")), diff --git a/crates/conformance/src/preservation.rs b/crates/conformance/src/preservation.rs index 0ec7ac991..0d7776bca 100644 --- a/crates/conformance/src/preservation.rs +++ b/crates/conformance/src/preservation.rs @@ -429,6 +429,29 @@ fn lean(root: &Path, arguments: &[String]) -> std::process::Output { .expect("lean runs") } +/// Compile one more module into a checked workspace's build, over the +/// modules [`check`] compiled: the planted or oracle module a case adds +/// after the workspace is checked. Returns Lean's output. +pub fn compile_text(root: &Path, module: &str, text: &str) -> std::process::Output { + let path = lexlean::production::preserve::module_path(module); + let source = root.join("src").join(&path); + std::fs::create_dir_all(source.parent().expect("a parent")).expect("mkdir"); + std::fs::write(&source, text).expect("write"); + let olean = root + .join("build") + .join(path.trim_end_matches(".lean")) + .with_extension("olean"); + std::fs::create_dir_all(olean.parent().expect("a parent")).expect("mkdir"); + lean( + root, + &[ + "-o".to_owned(), + olean.display().to_string(), + source.display().to_string(), + ], + ) +} + pub(crate) fn joined(output: &std::process::Output) -> String { format!( "{}{}", @@ -647,6 +670,144 @@ impl CompositionMutation { self.marks(text).len() } + /// How many places a certificate has for this defect: in its data when + /// it is held as data (SP-14), else in its text. + #[must_use] + pub fn places_in(self, certificate: &Certificate) -> usize { + match &certificate.data { + Some(data) => self.data_places(data).len(), + None => self.places(&certificate.text), + } + } + + /// The certificate with this defect planted at its `nth` place, as the + /// Lean text verification compiles: the data mutated and rendered by the + /// core backend for a certificate held as data, else the text. + #[must_use] + pub fn plant_in(self, certificate: &Certificate, nth: usize) -> Option { + match &certificate.data { + Some(data) => { + let planted = self.plant_data(data, nth)?; + Some( + lexlean::backend::core::lean_text_legacy(&planted, &certificate.module) + .expect("the planted module renders"), + ) + } + None => self.plant(&certificate.text, nth), + } + } + + /// The nodes of `data` this defect applies to: the constant of the + /// fallibility flag, each `fnIdent` application, the type of each + /// `__e_hrep` binder (one node, shared by the statement and the proof). + fn data_places(self, data: &lexlean::ir::core::CoreModule) -> Vec { + use lexlean::ir::core::CoreNode; + let mut out = Vec::new(); + for (index, node) in data.nodes.iter().enumerate() { + let hit = match (self, node) { + (Self::Fallibility, CoreNode::Const { n, .. }) => { + n == "Bool.true" || n == "Bool.false" + } + (Self::Function, CoreNode::App { f, x }) => { + matches!(&data.nodes[*f], CoreNode::Const { n, .. } if n == "LexLeanPreservation.Rust.fnIdent") + && matches!(&data.nodes[*x], CoreNode::Nat { .. }) + } + (Self::Hypothesis, CoreNode::Forall { n, t, .. }) => { + n == "__e_hrep" && !out.contains(t) + } + _ => false, + }; + if hit { + out.push(match (self, node) { + (Self::Hypothesis, CoreNode::Forall { t, .. }) => *t, + _ => index, + }); + } + } + out + } + + /// `data` with this defect planted at its `nth` place. The DAG is + /// rebuilt child before parent, the nodes a mutation adds inserted + /// before the first node that uses them. + fn plant_data( + self, + data: &lexlean::ir::core::CoreModule, + nth: usize, + ) -> Option { + use lexlean::ir::core::CoreNode; + let place = *self.data_places(data).get(nth)?; + let mut planted = data.clone(); + match self { + Self::Fallibility => { + if let CoreNode::Const { n, .. } = &mut planted.nodes[place] { + *n = if n == "Bool.true" { + "Bool.false".to_owned() + } else { + "Bool.true".to_owned() + }; + } + Some(planted) + } + Self::Function | Self::Hypothesis => { + // Rebuild with an index map, inserting the new nodes. + let mut nodes: Vec = Vec::with_capacity(data.nodes.len() + 4); + let mut map: Vec = Vec::with_capacity(data.nodes.len()); + let mut replacement: Option = None; + for (index, node) in data.nodes.iter().enumerate() { + let mut node = remap(node, &map); + if self == Self::Function && index == place { + if let CoreNode::App { x, .. } = &mut node { + let value = match &nodes[*x] { + CoreNode::Nat { v } => v.parse::().ok()? + 1, + _ => return None, + }; + nodes.push(CoreNode::Nat { + v: value.to_string(), + }); + *x = nodes.len() - 1; + } + } + if self == Self::Hypothesis { + if let CoreNode::Forall { n, t, .. } | CoreNode::Lambda { n, t, .. } = + &mut node + { + if n == "__e_hrep" && map[place] == *t { + let wrapped = *replacement.get_or_insert_with(|| { + let and = nodes.len(); + nodes.push(CoreNode::Const { + n: "And".to_owned(), + u: Vec::new(), + }); + nodes.push(CoreNode::Const { + n: "False".to_owned(), + u: Vec::new(), + }); + nodes.push(CoreNode::App { f: and, x: *t }); + nodes.push(CoreNode::App { + f: nodes.len() - 1, + x: and + 1, + }); + nodes.len() - 1 + }); + *t = wrapped; + } + } + } + map.push(nodes.len()); + nodes.push(node); + } + for row in &mut planted.declarations { + row.r#type = map[row.r#type]; + row.value = row.value.map(|value| map[value]); + } + planted.proof_nodes = planted.proof_nodes.iter().map(|p| map[*p]).collect(); + planted.nodes = nodes; + Some(planted) + } + } + } + /// `text` with this defect planted at its `nth` place, or `None` when it /// has none. #[must_use] @@ -674,6 +835,52 @@ impl CompositionMutation { } } +/// `node` with its children renumbered by `map`, which holds the new index +/// of every earlier node. +fn remap(node: &lexlean::ir::core::CoreNode, map: &[usize]) -> lexlean::ir::core::CoreNode { + use lexlean::ir::core::CoreNode; + match node { + CoreNode::App { f, x } => CoreNode::App { + f: map[*f], + x: map[*x], + }, + CoreNode::Lambda { n, b, t, v } => CoreNode::Lambda { + n: n.clone(), + b: *b, + t: map[*t], + v: map[*v], + }, + CoreNode::Forall { n, b, t, v } => CoreNode::Forall { + n: n.clone(), + b: *b, + t: map[*t], + v: map[*v], + }, + CoreNode::Let { n, t, v, body, d } => CoreNode::Let { + n: n.clone(), + t: map[*t], + v: map[*v], + body: map[*body], + d: *d, + }, + CoreNode::Mdata { m, x } => CoreNode::Mdata { + m: m.clone(), + x: map[*x], + }, + CoreNode::Projection { n, s, i, x } => CoreNode::Projection { + n: n.clone(), + s: s.clone(), + i: *i, + x: map[*x], + }, + other @ (CoreNode::BVar { .. } + | CoreNode::Sort { .. } + | CoreNode::Const { .. } + | CoreNode::Nat { .. } + | CoreNode::String { .. }) => other.clone(), + } +} + /// The byte offset of the end of each `RepresentableL [..]` hypothesis of /// `text`: where a conjunct can be appended to it. fn hypothesis_ends(text: &str) -> Vec { @@ -1031,11 +1238,11 @@ fn plant_composed( continue; }; for mutation in CompositionMutation::ALL { - let places = mutation.places(&composed.text); + let places = mutation.places_in(composed); assert!(places > 0, "{mutation:?} applies to `{}`", composed.module); for nth in 0..places { let mut text = mutation - .plant(&composed.text, nth) + .plant_in(composed, nth) .expect("the place was counted"); if mutation == CompositionMutation::Hypothesis { // A vacuous statement proves, so only applying it shows. diff --git a/crates/conformance/tests/conformance.rs b/crates/conformance/tests/conformance.rs index d029966d2..0d035589f 100644 --- a/crates/conformance/tests/conformance.rs +++ b/crates/conformance/tests/conformance.rs @@ -1590,6 +1590,11 @@ fn conformance_sp_13() { repo_conformance::cases::run("SP-13"); } +#[test] +fn conformance_sp_14() { + repo_conformance::cases::run("SP-14"); +} + #[test] fn conformance_md_01() { repo_conformance::cases::run("MD-01"); diff --git a/crates/lexlean/src/api/production.rs b/crates/lexlean/src/api/production.rs index 65bfd3d3f..8caa6c2a0 100644 --- a/crates/lexlean/src/api/production.rs +++ b/crates/lexlean/src/api/production.rs @@ -1341,7 +1341,12 @@ fn build_inner( &rendering.composed.theorem, ), ] { - let path = certificate_path(module); + // Certificate E is kernel-term data, recorded in the authoring + // notation (SPEC.md §17.17); A and B are Lean text. + let path = match role { + CertificateRole::E => crate::production::preserve::notation_path(module), + CertificateRole::A | CertificateRole::B => certificate_path(module), + }; certificates.push(CertificateRef { role, module: module.clone(), @@ -1828,7 +1833,15 @@ fn replay_files(files: &[(String, Vec)]) -> Result + crate::production::preserve::notation_path(module), + CertificateRole::A | CertificateRole::B => + certificate_path(module), + } + ) && ( stated_certificate.file.byte_length, stated_certificate.file.sha256, diff --git a/crates/lexlean/src/backend/core.rs b/crates/lexlean/src/backend/core.rs index c0b110c55..304706e89 100644 --- a/crates/lexlean/src/backend/core.rs +++ b/crates/lexlean/src/backend/core.rs @@ -1132,13 +1132,50 @@ fn append_core_command( /// Returns an internal diagnostic when the module's rows cannot be ordered /// or a chunk omits a node it needs. pub fn lean_text(core: &CoreModule) -> Result { - let mut text = String::from("module\n"); + lean_text_with(core, None) +} + +/// Render a native core module as Lean outside the module system: `import` +/// lines and no `module` header, the decoder and the data as [`lean_text`] +/// writes them, the decoder under the namespace `scope` (the module's own +/// name): outside the module system a file exports its declarations, and two +/// such modules imported together would declare the decoder twice. A +/// certificate held as data is rendered this way while the certificates it +/// imports are Lean text outside the module system, which a `module` cannot +/// import (SPEC.md §17.17). +/// +/// # Errors +/// +/// As [`lean_text`]. +pub fn lean_text_legacy(core: &CoreModule, scope: &str) -> Result { + lean_text_with(core, Some(scope)) +} + +fn lean_text_with(core: &CoreModule, legacy_scope: Option<&str>) -> Result { + let mut text = String::new(); + if legacy_scope.is_none() { + text.push_str("module\n"); + } for import in &core.imports { - text.push_str(&format!("public import {import}\n")); + if legacy_scope.is_none() { + text.push_str(&format!("public import {import}\n")); + } else { + text.push_str(&format!("import {import}\n")); + } } text.push_str( "import Lean\nset_option autoImplicit false\nset_option maxRecDepth 100000\nset_option maxHeartbeats 1000000000\nset_option Elab.async false\n\nopen Lean\n", ); + if let Some(scope) = legacy_scope { + // A certificate lifts the heartbeat budgets as its text form did + // (SPEC.md §17.17): what bounds the kernel's work is the wall clock. + text.push_str( + "set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +", + ); + text.push_str(&format!("namespace {scope}\n")); + } text.push_str(if core.version() == 2 { crate::backend::core_v2::LEAN_CORE_DECODER_V2 } else { @@ -1151,6 +1188,9 @@ pub fn lean_text(core: &CoreModule) -> Result { let chunk = core_chunk(core, &order[range.clone()], &owners)?; append_core_command(&mut text, core, &chunk)?; } + if let Some(scope) = legacy_scope { + text.push_str(&format!("\nend {scope}\n")); + } Ok(text) } diff --git a/crates/lexlean/src/ir/core.rs b/crates/lexlean/src/ir/core.rs index 6b9b0d1ab..70c272577 100644 --- a/crates/lexlean/src/ir/core.rs +++ b/crates/lexlean/src/ir/core.rs @@ -8,7 +8,7 @@ use std::collections::BTreeSet; use serde::{Deserialize, Serialize}; /// A universe level in the kernel calculus. -#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)] +#[derive(Debug, Clone, PartialEq, Hash, Eq, Deserialize, Serialize)] #[serde(tag = "k", content = "a")] #[serde(deny_unknown_fields)] pub enum CoreLevel { @@ -30,7 +30,7 @@ pub enum CoreLevel { } /// Binder visibility, preserved from the elaborated kernel expression. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)] +#[derive(Debug, Clone, Copy, PartialEq, Hash, Eq, Deserialize, Serialize)] pub enum CoreBinderInfo { /// Ordinary explicit binder. #[serde(rename = "e")] @@ -47,7 +47,7 @@ pub enum CoreBinderInfo { } /// One node of a closed Calculus-of-Inductive-Constructions expression. -#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)] +#[derive(Debug, Clone, PartialEq, Hash, Eq, Deserialize, Serialize)] #[serde(tag = "k")] #[serde(deny_unknown_fields)] pub enum CoreNode { @@ -113,7 +113,7 @@ pub enum CoreNode { } /// The value of one annotation entry. -#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)] +#[derive(Debug, Clone, PartialEq, Hash, Eq, Deserialize, Serialize)] #[serde(tag = "t")] #[serde(deny_unknown_fields)] pub enum CoreMetaValue { @@ -135,7 +135,7 @@ pub enum CoreMetaValue { } /// One `key := value` entry of an annotation. -#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)] +#[derive(Debug, Clone, PartialEq, Hash, Eq, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub struct CoreMetaEntry { /// The key name. diff --git a/crates/lexlean/src/production/certificate.rs b/crates/lexlean/src/production/certificate.rs index 655b0a0e8..74ee1c844 100644 --- a/crates/lexlean/src/production/certificate.rs +++ b/crates/lexlean/src/production/certificate.rs @@ -35,6 +35,8 @@ use std::collections::{BTreeMap, BTreeSet}; +mod data; + use super::eligibility::BUILTIN_OWNERS; use super::lean_list::{array, list, list_by}; use super::lower::{fixed_kind, Layout, Lowered, Origin, Validation}; @@ -84,6 +86,11 @@ pub struct Certificate { pub denote: String, /// The generated user modules the certificate imports. pub imports: Vec, + /// The certificate as kernel-term data, when it is held as data: a + /// native core module the core backend rendered `text` from (SP-14). + pub data: Option, + /// The record of a certificate held as data: its authoring notation. + pub source: Option, } /// One constructor of a closed document type, as tooling that writes @@ -437,50 +444,40 @@ pub fn certificate_e( ) -> Result { let mut generator = generator(modules, lowered, max_bytes); generator.nest().map_err(failure)?; - let text = generator - .compose(root_module, root_name, module_a, module_b, module, fallible) + let data = generator + .compose_data(root_module, root_name, module_a, module_b, module, fallible) .map_err(failure)?; - let text = from_the_root(&text).map_err(internal)?; + let text = crate::backend::core::lean_text_legacy(&data, module) + .map_err(|diagnostic| internal(diagnostic.message))?; generator.within(text.len()).map_err(failure)?; + let source = record_source(module, &data).map_err(internal)?; Ok(Certificate { module: module.to_owned(), theorem: format!("{module}.root"), denote: format!("{module_a}.denote"), text, imports: Vec::new(), + data: Some(data), + source: Some(source), }) } -/// `text` with every name certificate A defines (its encoders and their -/// bundles and auxiliaries) qualified by A's module. -fn qualify(text: &str, module_a: &str) -> String { - const DEFINED: [&str; 5] = ["__enc_", "__L_", "__O_", "__aux_", "__items_"]; - let mut out = String::new(); - let mut rest = text; - loop { - let found = DEFINED - .iter() - .filter_map(|prefix| rest.find(prefix).map(|at| (at, *prefix))) - .min(); - match found { - Some((at, prefix)) => { - let boundary = rest[..at].chars().next_back().is_none_or(|before| { - !(before.is_alphanumeric() || before == '_' || before == '.') - }); - out.push_str(&rest[..at]); - if boundary { - out.push_str(module_a); - out.push('.'); - } - out.push_str(prefix); - rest = rest.split_at(at + prefix.len()).1; - } - None => { - out.push_str(rest); - return out; - } - } - } +/// The record of a certificate held as data: the whole source of the module +/// in the authoring notation (SPEC.md §17.21.8), which reads back to the data. +fn record_source(module: &str, data: &crate::ir::core::CoreModule) -> Result { + let name = module.rsplit('.').next().unwrap_or(module); + let value = serde_json::to_value(data).map_err(|error| error.to_string())?; + crate::sdk::assemble( + &crate::sdk::SourceHeader { + name, + glossaries: &[], + imports: &[], + title: &format!("Certificate E {module}"), + }, + crate::sdk::ModuleKind::Core, + &value, + ) + .map_err(|error| error.message) } /// The generator of a lowered root's certificates, before nesting. @@ -595,6 +592,8 @@ pub fn certificate( denote: format!("{module}.denote"), text, imports, + data: None, + source: None, }) } @@ -7344,444 +7343,6 @@ impl Gen<'_> { } } -impl Gen<'_> { - /// The proof that every value of `ty`, encoded, is well typed: a term - /// of `∀ x, WT p c A (enc x) ty`. - fn wtf(&self, ty: &SemanticType, module_a: &str) -> Result { - match self.nested.get(&self.source.type_text(ty)) { - Some(nested) => { - let n = nested.index; - return Ok(match &nested.ty { - SemanticType::List { element: _ } - | SemanticType::Set { element: _ } - | SemanticType::Map { key: _, value: _ } - | SemanticType::ContractViolation - | SemanticType::ReasoningFailure => format!( - "({} {module_a}.__L_{n} {})", - lib("Rust.wt_listEnc"), - self.wtf(&element_of(ty)?, module_a)? - ), - SemanticType::Option { value } => format!( - "({} {module_a}.__O_{n} {})", - lib("Rust.wt_optEnc"), - self.wtf(value, module_a)? - ), - SemanticType::Result { ok: _, error: _ } - | SemanticType::Product { left: _, right: _ } - | SemanticType::Named { - member: _, - arguments: _, - } - | SemanticType::Function { - parameters: _, - result: _, - } - | SemanticType::Type - | SemanticType::Prop - | SemanticType::Parameter { name: _ } - | SemanticType::Nat - | SemanticType::Bool - | SemanticType::Unit - | SemanticType::Int - | SemanticType::Int8 - | SemanticType::Int16 - | SemanticType::Int32 - | SemanticType::Int64 - | SemanticType::UInt8 - | SemanticType::UInt16 - | SemanticType::UInt32 - | SemanticType::UInt64 - | SemanticType::String - | SemanticType::Bytes - | SemanticType::Ordering => format!("__wtAux_{n}"), - }); - } - None => {} - } - let rust = |name: &str| lib(&format!("Rust.{name}")); - Ok(match ty { - SemanticType::Nat => rust("wt_nat"), - SemanticType::Int => rust("wt_int"), - SemanticType::Bool => rust("wt_bool"), - SemanticType::String => rust("wt_string"), - SemanticType::Bytes => rust("wt_bytes"), - SemanticType::Unit => rust("wt_encUnit"), - SemanticType::Ordering => rust("wt_encOrdering"), - SemanticType::UInt8 => rust("wt_u8"), - SemanticType::UInt16 => rust("wt_u16"), - SemanticType::UInt32 => rust("wt_u32"), - SemanticType::UInt64 => rust("wt_u64"), - SemanticType::Int8 => rust("wt_i8"), - SemanticType::Int16 => rust("wt_i16"), - SemanticType::Int32 => rust("wt_i32"), - SemanticType::Int64 => rust("wt_i64"), - SemanticType::Option { value } => { - format!("({} {})", rust("wt_encOption"), self.wtf(value, module_a)?) - } - SemanticType::Result { ok, error } => format!( - "({} {} {})", - rust("wt_encExcept"), - self.wtf(error, module_a)?, - self.wtf(ok, module_a)? - ), - SemanticType::List { element } | SemanticType::Set { element } => { - format!("({} {})", rust("wt_encList"), self.wtf(element, module_a)?) - } - SemanticType::Map { key, value } => format!( - "({} ({} {} {}))", - rust("wt_encList"), - rust("wt_encPair"), - self.wtf(key, module_a)?, - self.wtf(value, module_a)? - ), - SemanticType::Product { left, right } => format!( - "({} {} {})", - rust("wt_encPair"), - self.wtf(left, module_a)?, - self.wtf(right, module_a)? - ), - SemanticType::ContractViolation | SemanticType::ReasoningFailure => format!( - "({} {} {})", - rust("wt_encPair"), - rust("wt_bool"), - rust("wt_bool") - ), - SemanticType::Named { - member: _, - arguments: _, - } => { - let text = self.source.type_text(ty); - let index = self - .adts - .get(&text) - .ok_or_else(|| format!("`{text}` has no ADT in the layout"))?; - format!("__wt_{index}") - } - SemanticType::Function { - parameters: _, - result: _, - } - | SemanticType::Type - | SemanticType::Prop - | SemanticType::Parameter { name: _ } => { - return Err(format!( - "`{}` crosses no root boundary", - self.source.type_text(ty) - )); - } - }) - } - - /// The well-typedness proof of `arg` encoded as a field inside a - /// recursive group, as [`Self::raw_apply`] encodes it. - fn wt_apply(&self, ty: &SemanticType, arg: &str, module_a: &str) -> Result { - match self.nested.get(&self.source.type_text(ty)) { - Some(nested) => Ok(match &nested.ty { - SemanticType::List { element: _ } - | SemanticType::Set { element: _ } - | SemanticType::Map { key: _, value: _ } - | SemanticType::ContractViolation - | SemanticType::ReasoningFailure => format!( - "({} (__wtItems_{} {arg}))", - lib("Rust.wt_list"), - nested.index - ), - SemanticType::Option { value: _ } - | SemanticType::Result { ok: _, error: _ } - | SemanticType::Product { left: _, right: _ } - | SemanticType::Named { - member: _, - arguments: _, - } - | SemanticType::Function { - parameters: _, - result: _, - } - | SemanticType::Type - | SemanticType::Prop - | SemanticType::Parameter { name: _ } - | SemanticType::Nat - | SemanticType::Bool - | SemanticType::Unit - | SemanticType::Int - | SemanticType::Int8 - | SemanticType::Int16 - | SemanticType::Int32 - | SemanticType::Int64 - | SemanticType::UInt8 - | SemanticType::UInt16 - | SemanticType::UInt32 - | SemanticType::UInt64 - | SemanticType::String - | SemanticType::Bytes - | SemanticType::Ordering => format!("(__wtAux_{} {arg})", nested.index), - }), - None => Ok(format!("({} {arg})", self.wtf(ty, module_a)?)), - } - } - - /// A list of well-typedness proofs as one proof of `WTL`. - fn wtl(proofs: &[String]) -> String { - proofs.iter().rev().fold(lib("Rust.wtl_nil"), |tail, head| { - format!("({} {head} {tail})", lib("Rust.wtl_cons")) - }) - } - - /// The well-typedness theorems of every document type's encoder and of - /// the auxiliaries nested in a recursive group, by the same recursion - /// as the encoders: one mutual block per group. - fn wt_theorems(&self, module_a: &str, sem: &str) -> Result { - let graph = self.adt_graph()?; - let mut texts: BTreeMap = BTreeMap::new(); - for (index, adt) in self.layout.adts.iter().enumerate() { - let index = index as u64; - let shape = self.source.document(&adt.ty)?; - let lean = self.ty(&adt.ty)?; - let recursive = self.nested.values().any(|nested| nested.group == index) - || components(&graph) - .iter() - .any(|component| component.len() > 1 && component.contains(&index)) - || graph - .get(&index) - .is_some_and(|edges| edges.contains(&index)); - let statement = |binder: &str| { - format!( - "{} {sem} ({module_a}.__enc_{index} {binder}) (.adt {index})", - lib("Rust.WT") - ) - }; - let text = if shape.kind == "inductive" || recursive { - let owner = lean - .trim_start_matches('(') - .split(' ') - .next() - .unwrap_or_default() - .trim_end_matches(')') - .to_owned(); - let mut text = format!( - "theorem __wt_{index} : ∀ (__v : {lean}), {}\n", - statement("__v") - ); - for (constructor, fields) in shape.names.iter().zip(&shape.fields) { - let binders: Vec = (0..fields.len()) - .map(|field| format!("__x{field}")) - .collect(); - let proofs = fields - .iter() - .zip(&binders) - .map(|(field, binder)| self.wt_apply(field, binder, module_a)) - .collect::, _>>()?; - let pattern = if shape.kind == "inductive" { - format!( - "{owner}.{}{}", - identifier(constructor), - binders - .iter() - .map(|binder| format!(" {binder}")) - .collect::() - ) - } else { - format!("⟨{}⟩", binders.join(", ")) - }; - text.push_str(&format!( - " | {pattern} => {} rfl {}\n", - lib("Rust.wt_adt"), - Self::wtl(&proofs) - )); - } - text.push('\n'); - text - } else { - let proofs = shape - .field_names - .iter() - .zip(&shape.fields[0]) - .map(|(name, ty)| { - Ok::(format!( - "({} (__s).{})", - self.wtf(ty, module_a)?, - identifier(name) - )) - }) - .collect::, _>>()?; - format!( - "theorem __wt_{index} : ∀ (__s : {lean}), {} :=\n fun __s => {} rfl {}\n\n", - statement("__s"), - lib("Rust.wt_adt"), - Self::wtl(&proofs) - ) - }; - texts.insert(index, text); - } - let mut out = String::new(); - for component in components(&graph) { - let mut items: Vec = - component.iter().map(|index| texts[index].clone()).collect(); - let mut nested: Vec<&Nested> = self - .nested - .values() - .filter(|nested| nested.group == component[0]) - .collect(); - nested.sort_by_key(|nested| nested.index); - for nested in nested { - items.push(self.wt_auxiliary(nested, module_a, sem)?); - } - out.push_str(&mutual_block(&items)); - } - Ok(out) - } - - /// The well-typedness theorem of a nested container's auxiliary. - fn wt_auxiliary(&self, nested: &Nested, module_a: &str, sem: &str) -> Result { - let lean = self.ty(&nested.ty)?; - let n = nested.index; - let target = render_ty(&self.target_ty(&nested.ty)?); - let wt = lib("Rust.WT"); - Ok(match &nested.ty { - SemanticType::List { element: _ } - | SemanticType::Set { element: _ } - | SemanticType::Map { key: _, value: _ } - | SemanticType::ContractViolation | SemanticType::ReasoningFailure => { - let element = element_of(&nested.ty)?; - format!( - "theorem __wtItems_{n} : ∀ (__v : {lean}), {} {sem} ({module_a}.__items_{n} __v) {}\n | [] => {}\n | __x0 :: __x1 => {} {} (__wtItems_{n} __x1)\n\n", - lib("Rust.WTAll"), - render_ty(&self.target_ty(&element)?), - lib("Rust.wtAll_nil"), - lib("Rust.wtAll_cons"), - self.wt_apply(&element, "__x0", module_a)? - ) - } - SemanticType::Option { value: inner } => format!( - "theorem __wtAux_{n} : ∀ (__v : {lean}), {wt} {sem} ({module_a}.__aux_{n} __v) {target}\n | none => {}\n | some __x0 => {} {}\n\n", - lib("Rust.wt_noneV"), - lib("Rust.wt_someV"), - self.wt_apply(inner, "__x0", module_a)? - ), - SemanticType::Product { left, right } => format!( - "theorem __wtAux_{n} : ∀ (__v : {lean}), {wt} {sem} ({module_a}.__aux_{n} __v) {target}\n | (__x0, __x1) => {} {} {}\n\n", - lib("Rust.wt_pairV"), - self.wt_apply(left, "__x0", module_a)?, - self.wt_apply(right, "__x1", module_a)? - ), - SemanticType::Result { ok, error } => format!( - "theorem __wtAux_{n} : ∀ (__v : {lean}), {wt} {sem} ({module_a}.__aux_{n} __v) {target}\n | Except.error __x0 => {} {}\n | Except.ok __x0 => {} {}\n\n", - lib("Rust.wt_errorV"), - self.wt_apply(error, "__x0", module_a)?, - lib("Rust.wt_okV"), - self.wt_apply(ok, "__x0", module_a)? - ), - SemanticType::Named { - member: _, - arguments: _, - } - | SemanticType::Function { - parameters: _, - result: _, - } - | SemanticType::Type - | SemanticType::Prop - | SemanticType::Parameter { name: _ } - | SemanticType::Nat - | SemanticType::Bool - | SemanticType::Unit - | SemanticType::Int - | SemanticType::Int8 - | SemanticType::Int16 - | SemanticType::Int32 - | SemanticType::Int64 - | SemanticType::UInt8 - | SemanticType::UInt16 - | SemanticType::UInt32 - | SemanticType::UInt64 - | SemanticType::String - | SemanticType::Bytes - | SemanticType::Ordering => { - return Err(format!( - "`{}` is not a nested container", - self.source.type_text(&nested.ty) - )); - } - }) - } - - /// The text of certificate E. - fn compose( - &self, - root_module: &str, - root_name: &str, - module_a: &str, - module_b: &str, - name: &str, - fallible: bool, - ) -> Result { - let fallible = match fallible { - true => TRUE, - false => "Bool.false", - }; - let sem = format!("{module_b}.program {module_b}.krate {module_b}.flags"); - let mut out = format!( - "import {module_a}\nimport {module_b}\nimport LexLeanPreservation.Compose\nset_option autoImplicit false\nset_option maxRecDepth 100000\n{}set_option linter.unusedVariables false\nnamespace {name}\n\n", - super::lower::budget_options(self.program) - ); - out.push_str(&self.wt_theorems(module_a, &sem)?); - let (parameters, _) = self.source.signature(root_module, root_name, &[])?; - let mut binders = Vec::new(); - let mut names = Vec::new(); - let mut arguments = Vec::new(); - let mut proofs = Vec::new(); - for SemanticParameter { - name: local, - r#type, - } in ¶meters - { - let local = identifier(local); - binders.push(format!("({local} : {})", self.ty(r#type)?)); - arguments.push(format!( - "({} {local})", - qualify(&self.enc(r#type)?, module_a) - )); - proofs.push(format!("({} {local})", self.wtf(r#type, module_a)?)); - names.push(local); - } - let applied: String = names.iter().map(|local| format!(" {local}")).collect(); - let argument_list = list(arguments); - match self.entry_of() { - // The root's entry validates the parameters that carry an - // invariant before calling the root: its rendering realizes the - // root's observation as `some` when §17.12's invariants hold, - // and `none` when one fails. - Some((entry, _)) => out.push_str(&format!( - "/-- The rendering of the root's entry, invoked on the encoded arguments,\nrealizes the encoded source result when the arguments satisfy §17.12's\ninvariants, and refuses them with `none` otherwise. -/\ntheorem root {} (__e_hrep : {} {argument_list}) : ∃ __e_ro, {} {module_b}.krate ({} {entry}) {argument_list} __e_ro ∧\n ({module_a}.accepts{applied} → {} {fallible} ({} ({module_a}.denote{applied})) __e_ro) ∧\n (¬ {module_a}.accepts{applied} → {} {fallible} ({}.value {SYNTAX}.Value.none) __e_ro) :=\n match {} (fun __e_n => {module_b}.root __e_n {entry}) rfl {} rfl rfl ({module_a}.entry{applied}) ({} _ _) with\n | ⟨__e_ro, __e_hr, __e_hc⟩ => ⟨__e_ro, __e_hc, fun __e_h => {module_a}.entry_accepts{applied} __e_h ▸ __e_hr, fun __e_h => {module_a}.entry_refuses{applied} __e_h ▸ __e_hr⟩\n\n", - binders.join(" "), - lib("Rust.RepresentableL"), - lib("Rust.RCI"), - lib("Rust.fnIdent"), - lib("Rust.RealizesFn"), - lib("someObs"), - lib("Rust.RealizesFn"), - lib("Obs"), - lib("Rust.compose"), - Self::wtl(&proofs), - lib("Rust.rel_ne_stuck"), - )), - None => out.push_str(&format!( - "/-- The rendering of the root, invoked on the encoded arguments, realizes\nthe encoded source result. -/\ntheorem root {} (__e_hrep : {} {argument_list}) : ∃ __e_ro, {} {fallible} ({module_a}.denote{applied}) __e_ro ∧ {} {module_b}.krate ({} 0) {argument_list} __e_ro :=\n {} (fun __e_n => {module_b}.root __e_n 0) rfl {} rfl rfl ({module_a}.root{applied}) ({} _ _)\n\n", - binders.join(" "), - lib("Rust.RepresentableL"), - lib("Rust.RealizesFn"), - lib("Rust.RCI"), - lib("Rust.fnIdent"), - lib("Rust.compose"), - Self::wtl(&proofs), - lib("Rust.rel_ne_stuck"), - )), - } - out.push_str(&format!("end {name}\n")); - Ok(out) - } -} - // --- The boundary (SPEC.md §17.17) ------------------------------------------ /// One validator's four statements: its definition, its proposition, the diff --git a/crates/lexlean/src/production/certificate/data.rs b/crates/lexlean/src/production/certificate/data.rs new file mode 100644 index 000000000..661d7ef03 --- /dev/null +++ b/crates/lexlean/src/production/certificate/data.rs @@ -0,0 +1,2290 @@ +//! Certificate E as kernel-term data (SPEC.md §17.17, `SP-14`). +//! +//! Certificate E of one rendering of a root states that the crate's root, +//! invoked on the encoded arguments, realizes certificate A's observation of +//! the root: it composes certificate A (the root's semantics) with +//! certificate B (the crate's simulation of the lowered program) through the +//! library's `compose` theorem, after proving every encoded argument well +//! typed for the crate. Here the module is built as a native core module: a +//! theorem row per document type (`__wt_k`, the well-typedness of its +//! encoder) and the `root` row, each a kernel term whose every argument is +//! written, the lemma types read from the native preservation library and +//! instantiated one binder at a time ([`super::super::kernel`]). +//! +//! What the text generator spells for Lean's elaborator, this generator +//! writes out: the implicit program, crate, and flags of every lemma, the +//! element types and encoders of the container lemmas, the field values and +//! types of a document, the environment the entry binds, and the observation +//! `compose` relates. An `rfl` is `Eq.refl` at the equation the lemma states. +//! The statements are the text generator's, so the kernel term each theorem +//! states is the one the text elaborated to. + +use std::collections::{BTreeMap, BTreeSet, HashMap}; + +use super::super::kernel::{Arg, Builder, Term}; +use super::super::preserve::{self, CERTIFICATE_AXIOMS}; +use super::{components, Gen, Nested, SYNTAX}; +use crate::calculus::Ty; +use crate::ir::core::{ + CoreAxiomPolicy, CoreBinderInfo, CoreDeclKind, CoreDeclaration, CoreModule, CoreTransparency, + CORE_SPEC_2, +}; +use crate::ir::semantic::{MemberRef, SemanticParameter, SemanticType}; + +const LIB: &str = "LexLeanPreservation"; +const RUST: &str = "LexLeanPreservation.Rust"; +/// The library module certificate E imports, which imports the rest. +pub(super) const COMPOSE_MODULE: &str = "LexLeanPreservation.Compose"; + +/// The builder of one certificate E module. +struct Composer<'g, 'a> { + gen: &'g Gen<'a>, + b: Builder, + module_a: String, + module_b: String, + name: String, + /// `module_b.program`, `module_b.krate`, `module_b.flags`. + p: Term, + c: Term, + a: Term, + /// The lemma heads and imported types by name. + lemmas: HashMap, + /// The axioms of each row built so far, by row name, for the rows that + /// apply them. + row_axioms: BTreeMap>, + /// The names of the module's own rows a term applies, since the last + /// [`Self::take_references`]. + references: BTreeSet, +} + +/// One row of the module. +struct Row { + name: String, + ty: Term, + value: Term, + axioms: BTreeSet, +} + +impl<'g, 'a> Composer<'g, 'a> { + fn new(gen: &'g Gen<'a>, module_a: &str, module_b: &str, name: &str) -> Self { + let mut b = Builder::new(); + let p = b.konst(&format!("{module_b}.program")); + let c = b.konst(&format!("{module_b}.krate")); + let a = b.konst(&format!("{module_b}.flags")); + Self { + gen, + b, + module_a: module_a.to_owned(), + module_b: module_b.to_owned(), + name: name.to_owned(), + p, + c, + a, + lemmas: HashMap::new(), + row_axioms: BTreeMap::new(), + references: BTreeSet::new(), + } + } + + // --- Names ------------------------------------------------------------ + + fn syntax(&mut self, name: &str) -> Term { + self.b.konst(&format!("{SYNTAX}.{name}")) + } + + fn library(&mut self, name: &str) -> Term { + self.b.konst(&format!("{LIB}.{name}")) + } + + fn rust(&mut self, name: &str) -> Term { + self.b.konst(&format!("{RUST}.{name}")) + } + + fn own(&mut self, name: &str) -> Term { + let full = format!("{}.{name}", self.name); + self.references.insert(full.clone()); + self.b.konst(&full) + } + + fn of_a(&mut self, name: &str) -> Term { + self.b.konst(&format!("{}.{name}", self.module_a)) + } + + fn take_references(&mut self) -> BTreeSet { + std::mem::take(&mut self.references) + } + + /// The head and type of a library lemma, its type imported from the + /// native library data. + fn lemma(&mut self, name: &str) -> Result<(Term, Term), String> { + if let Some(&found) = self.lemmas.get(name) { + self.b.note_lemma(name); + return Ok(found); + } + let (module, declaration) = preserve::native_declaration(name)?; + if !declaration.levels.is_empty() { + return Err(format!( + "`{name}` has universe parameters, which a certificate does not instantiate" + )); + } + let ty = self.b.import(module, declaration.r#type); + let head = self.b.konst(name); + self.lemmas.insert(name.to_owned(), (head, ty)); + self.b.note_lemma(name); + Ok((head, ty)) + } + + /// A library lemma applied to `args`. + fn apply(&mut self, name: &str, args: &[Arg]) -> Result { + let (head, ty) = self.lemma(name)?; + self.b + .apply_pi(head, ty, args) + .map(|applied| applied.term) + .map_err(|reason| format!("`{name}`: {reason}")) + } + + fn rust_lemma(&mut self, name: &str, args: &[Arg]) -> Result { + self.apply(&format!("{RUST}.{name}"), args) + } + + // --- Types ------------------------------------------------------------ + + /// The Lean type of a closed source type, as a kernel term. + fn lean_type(&mut self, ty: &SemanticType) -> Result { + Ok(match ty { + SemanticType::Nat => self.b.konst("Nat"), + SemanticType::Bool => self.b.konst("Bool"), + SemanticType::Unit => self.b.konst("Unit"), + SemanticType::Int => self.b.konst("Int"), + SemanticType::Int8 => self.b.konst("Int8"), + SemanticType::Int16 => self.b.konst("Int16"), + SemanticType::Int32 => self.b.konst("Int32"), + SemanticType::Int64 => self.b.konst("Int64"), + SemanticType::UInt8 => self.b.konst("UInt8"), + SemanticType::UInt16 => self.b.konst("UInt16"), + SemanticType::UInt32 => self.b.konst("UInt32"), + SemanticType::UInt64 => self.b.konst("UInt64"), + SemanticType::String => self.b.konst("String"), + SemanticType::Bytes => self.b.konst("ByteArray"), + SemanticType::Ordering => self.b.konst("Ordering"), + SemanticType::ContractViolation | SemanticType::ReasoningFailure => { + let bool = self.b.konst("Bool"); + self.b.pair_ty(bool, bool) + } + SemanticType::Option { value } => { + let inner = self.lean_type(value)?; + let option = self.b.konst0("Option"); + self.b.app(option, inner) + } + SemanticType::Result { ok, error } => { + let error = self.lean_type(error)?; + let ok = self.lean_type(ok)?; + let except = self.b.konst00("Except"); + self.b.apps(except, &[error, ok]) + } + SemanticType::List { element } | SemanticType::Set { element } => { + let element = self.lean_type(element)?; + self.b.list_ty(element) + } + SemanticType::Product { left, right } => { + let left = self.lean_type(left)?; + let right = self.lean_type(right)?; + self.b.pair_ty(left, right) + } + SemanticType::Map { key, value } => { + let key = self.lean_type(key)?; + let value = self.lean_type(value)?; + let entry = self.b.pair_ty(key, value); + self.b.list_ty(entry) + } + SemanticType::Named { member, arguments } => { + let head = self.document_name(member)?; + let head = self.b.konst(&head); + let mut args = Vec::new(); + for argument in arguments { + args.push(self.lean_type(argument)?); + } + self.b.apps(head, &args) + } + SemanticType::Function { + parameters: _, + result: _, + } + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } => { + return Err(format!( + "`{}` has no runtime encoding", + self.gen.source.type_text(ty) + )); + } + }) + } + + /// The Lean name of a document type. + fn document_name(&self, member: &MemberRef) -> Result { + let module = member.module.clone().ok_or("an unanchored document type")?; + Ok(format!( + "{}.{}", + self.gen.source.lean_module(&module)?, + member.name + )) + } + + /// A target type as a kernel term. + fn target_ty(&mut self, ty: &Ty) -> Term { + match ty { + Ty::Unit => self.syntax("Ty.unit"), + Ty::Bool => self.syntax("Ty.bool"), + Ty::Nat => self.syntax("Ty.nat"), + Ty::Int => self.syntax("Ty.int"), + Ty::Fixed { width } => { + let fixed = self.syntax("Ty.fixed"); + let kind = self.syntax(&format!("IntKind.{}", width.name())); + self.b.app(fixed, kind) + } + Ty::String => self.syntax("Ty.string"), + Ty::Bytes => self.syntax("Ty.bytes"), + Ty::Ordering => self.syntax("Ty.ordering"), + Ty::Option { value } => { + let inner = self.target_ty(value); + let option = self.syntax("Ty.option"); + self.b.app(option, inner) + } + Ty::Result { ok, error } => { + let ok = self.target_ty(ok); + let error = self.target_ty(error); + let result = self.syntax("Ty.result"); + self.b.apps(result, &[ok, error]) + } + Ty::List { element } => { + let element = self.target_ty(element); + let list = self.syntax("Ty.list"); + self.b.app(list, element) + } + Ty::Pair { left, right } => { + let left = self.target_ty(left); + let right = self.target_ty(right); + let pair = self.syntax("Ty.pair"); + self.b.apps(pair, &[left, right]) + } + Ty::Adt { index } => { + let adt = self.syntax("Ty.adt"); + let index = self.b.nat(*index); + self.b.app(adt, index) + } + Ty::Fn { parameters, result } => { + let ty = self.syntax("Ty"); + let mut items = Vec::new(); + for parameter in parameters { + items.push(self.target_ty(parameter)); + } + let parameters = self.b.list(ty, &items); + let result = self.target_ty(result); + let function = self.syntax("Ty.fn"); + self.b.apps(function, &[parameters, result]) + } + } + } + + /// The target type a source type is encoded at. + fn encoded_ty(&mut self, ty: &SemanticType) -> Result { + let target = self.gen.target_ty(ty)?; + Ok(self.target_ty(&target)) + } + + // --- Encoders --------------------------------------------------------- + + /// The encoder of a closed source type into target values, as the term + /// certificate A applies (`enc` and the nested auxiliaries). + fn encoder(&mut self, ty: &SemanticType) -> Result { + if let Some(nested) = self.gen.nested.get(&self.gen.source.type_text(ty)) { + return self.nested_encoder(nested); + } + Ok(match ty { + SemanticType::Nat => self.syntax("Value.nat"), + SemanticType::Bool => self.syntax("Value.bool"), + SemanticType::Int => self.syntax("Value.int"), + SemanticType::Int8 => self.syntax("Value.i8"), + SemanticType::Int16 => self.syntax("Value.i16"), + SemanticType::Int32 => self.syntax("Value.i32"), + SemanticType::Int64 => self.syntax("Value.i64"), + SemanticType::UInt8 => self.syntax("Value.u8"), + SemanticType::UInt16 => self.syntax("Value.u16"), + SemanticType::UInt32 => self.syntax("Value.u32"), + SemanticType::UInt64 => self.syntax("Value.u64"), + SemanticType::String => self.syntax("Value.string"), + SemanticType::Bytes => self.syntax("Value.bytes"), + SemanticType::Unit => self.library("encUnit"), + SemanticType::Ordering => self.library("encOrdering"), + SemanticType::ContractViolation | SemanticType::ReasoningFailure => { + let bool = self.b.konst("Bool"); + let value_bool = self.syntax("Value.bool"); + let pair = self.library("encPair"); + self.b.apps(pair, &[bool, bool, value_bool, value_bool]) + } + SemanticType::Option { value } => { + let alpha = self.lean_type(value)?; + let inner = self.encoder(value)?; + let option = self.library("encOption"); + self.b.apps(option, &[alpha, inner]) + } + SemanticType::Result { ok, error } => { + let epsilon = self.lean_type(error)?; + let alpha = self.lean_type(ok)?; + let error = self.encoder(error)?; + let ok = self.encoder(ok)?; + let except = self.library("encExcept"); + self.b.apps(except, &[epsilon, alpha, error, ok]) + } + SemanticType::List { element } | SemanticType::Set { element } => { + let alpha = self.lean_type(element)?; + let inner = self.encoder(element)?; + let list = self.library("encList"); + self.b.apps(list, &[alpha, inner]) + } + SemanticType::Product { left, right } => { + let alpha = self.lean_type(left)?; + let beta = self.lean_type(right)?; + let left = self.encoder(left)?; + let right = self.encoder(right)?; + let pair = self.library("encPair"); + self.b.apps(pair, &[alpha, beta, left, right]) + } + SemanticType::Map { key, value } => { + let entry = SemanticType::Product { + left: key.clone(), + right: value.clone(), + }; + let alpha = self.lean_type(&entry)?; + let inner = self.encoder(&entry)?; + let list = self.library("encList"); + self.b.apps(list, &[alpha, inner]) + } + SemanticType::Named { + member: _, + arguments: _, + } => { + let index = self.adt_index(ty)?; + self.of_a(&format!("__enc_{index}")) + } + SemanticType::Function { + parameters: _, + result: _, + } + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } => { + return Err(format!( + "`{}` has no runtime encoding", + self.gen.source.type_text(ty) + )); + } + }) + } + + /// The encoder of a container nested in a recursive group: certificate + /// A's auxiliary. + fn nested_encoder(&mut self, nested: &Nested) -> Result { + let n = nested.index; + Ok(match &nested.ty { + SemanticType::List { element } + | SemanticType::Set { element } + | SemanticType::Map { + key: _, + value: element, + } => { + let element = element_type(&nested.ty, element); + let alpha = self.lean_type(&element)?; + let enc = self.library("ListEnc.enc"); + let aux = self.of_a(&format!("__L_{n}")); + self.b.apps(enc, &[alpha, aux]) + } + SemanticType::ContractViolation | SemanticType::ReasoningFailure => { + let bool = self.b.konst("Bool"); + let alpha = self.b.pair_ty(bool, bool); + let enc = self.library("ListEnc.enc"); + let aux = self.of_a(&format!("__L_{n}")); + self.b.apps(enc, &[alpha, aux]) + } + SemanticType::Option { value } => { + let alpha = self.lean_type(value)?; + let enc = self.library("OptEnc.enc"); + let aux = self.of_a(&format!("__O_{n}")); + self.b.apps(enc, &[alpha, aux]) + } + SemanticType::Result { ok: _, error: _ } + | SemanticType::Product { left: _, right: _ } + | SemanticType::Named { + member: _, + arguments: _, + } + | SemanticType::Function { + parameters: _, + result: _, + } + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } + | SemanticType::Nat + | SemanticType::Bool + | SemanticType::Unit + | SemanticType::Int + | SemanticType::Int8 + | SemanticType::Int16 + | SemanticType::Int32 + | SemanticType::Int64 + | SemanticType::UInt8 + | SemanticType::UInt16 + | SemanticType::UInt32 + | SemanticType::UInt64 + | SemanticType::String + | SemanticType::Bytes + | SemanticType::Ordering => self.of_a(&format!("__aux_{n}")), + }) + } + + /// The ADT index of a document type in the layout. + fn adt_index(&self, ty: &SemanticType) -> Result { + let text = self.gen.source.type_text(ty); + self.gen + .adts + .get(&text) + .copied() + .ok_or_else(|| format!("`{text}` has no ADT in the layout")) + } + + /// `encoder ty` applied to `value`. + fn encode(&mut self, ty: &SemanticType, value: Term) -> Result { + let encoder = self.encoder(ty)?; + Ok(self.b.app(encoder, value)) + } + + // --- Well-typedness proofs -------------------------------------------- + + /// The proof that the encoding of `arg : ty` is well typed at the + /// encoded target type, as [`Gen::wt_apply`] writes it. + fn wt_apply(&mut self, ty: &SemanticType, arg: Term) -> Result { + if let Some(nested) = self.gen.nested.get(&self.gen.source.type_text(ty)) { + let n = nested.index; + return match &nested.ty { + SemanticType::List { element: _ } + | SemanticType::Set { element: _ } + | SemanticType::Map { key: _, value: _ } + | SemanticType::ContractViolation + | SemanticType::ReasoningFailure => { + let items = self.of_a(&format!("__items_{n}")); + let items = self.b.app(items, arg); + let element = super::element_of(&nested.ty)?; + let t = self.encoded_ty(&element)?; + let wt_items = self.own(&format!("__wtItems_{n}")); + let h = self.b.app(wt_items, arg); + let (p, c, a) = (self.p, self.c, self.a); + self.rust_lemma( + "wt_list", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(items), + Arg::Term(t), + Arg::Term(h), + ], + ) + } + SemanticType::Option { value: _ } + | SemanticType::Result { ok: _, error: _ } + | SemanticType::Product { left: _, right: _ } + | SemanticType::Named { + member: _, + arguments: _, + } + | SemanticType::Function { + parameters: _, + result: _, + } + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } + | SemanticType::Nat + | SemanticType::Bool + | SemanticType::Unit + | SemanticType::Int + | SemanticType::Int8 + | SemanticType::Int16 + | SemanticType::Int32 + | SemanticType::Int64 + | SemanticType::UInt8 + | SemanticType::UInt16 + | SemanticType::UInt32 + | SemanticType::UInt64 + | SemanticType::String + | SemanticType::Bytes + | SemanticType::Ordering => { + let aux = self.own(&format!("__wtAux_{n}")); + Ok(self.b.app(aux, arg)) + } + }; + } + let (p, c, a) = (self.p, self.c, self.a); + let scalar = |this: &mut Self, lemma: &str| { + this.rust_lemma( + lemma, + &[Arg::Term(p), Arg::Term(c), Arg::Term(a), Arg::Term(arg)], + ) + }; + match ty { + SemanticType::Nat => scalar(self, "wt_nat"), + SemanticType::Int => scalar(self, "wt_int"), + SemanticType::Bool => scalar(self, "wt_bool"), + SemanticType::String => scalar(self, "wt_string"), + SemanticType::Bytes => scalar(self, "wt_bytes"), + SemanticType::Unit => scalar(self, "wt_encUnit"), + SemanticType::Ordering => scalar(self, "wt_encOrdering"), + SemanticType::UInt8 => scalar(self, "wt_u8"), + SemanticType::UInt16 => scalar(self, "wt_u16"), + SemanticType::UInt32 => scalar(self, "wt_u32"), + SemanticType::UInt64 => scalar(self, "wt_u64"), + SemanticType::Int8 => scalar(self, "wt_i8"), + SemanticType::Int16 => scalar(self, "wt_i16"), + SemanticType::Int32 => scalar(self, "wt_i32"), + SemanticType::Int64 => scalar(self, "wt_i64"), + SemanticType::Option { value } => { + let alpha = self.lean_type(value)?; + let e = self.encoder(value)?; + let t = self.encoded_ty(value)?; + let h = self.wt_function(value)?; + self.rust_lemma( + "wt_encOption", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(alpha), + Arg::Term(e), + Arg::Term(t), + Arg::Term(h), + Arg::Term(arg), + ], + ) + } + SemanticType::List { element } | SemanticType::Set { element } => { + self.wt_list(element, arg) + } + SemanticType::Map { key, value } => { + let entry = SemanticType::Product { + left: key.clone(), + right: value.clone(), + }; + self.wt_list(&entry, arg) + } + SemanticType::Product { left, right } => self.wt_pair(left, right, arg), + SemanticType::ContractViolation | SemanticType::ReasoningFailure => { + self.wt_pair(&SemanticType::Bool, &SemanticType::Bool, arg) + } + SemanticType::Result { ok, error } => { + let epsilon = self.lean_type(error)?; + let alpha = self.lean_type(ok)?; + let ee = self.encoder(error)?; + let ea = self.encoder(ok)?; + let s = self.encoded_ty(ok)?; + let t = self.encoded_ty(error)?; + let he = self.wt_function(error)?; + let ha = self.wt_function(ok)?; + self.rust_lemma( + "wt_encExcept", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(epsilon), + Arg::Term(alpha), + Arg::Term(ee), + Arg::Term(ea), + Arg::Term(s), + Arg::Term(t), + Arg::Term(he), + Arg::Term(ha), + Arg::Term(arg), + ], + ) + } + SemanticType::Named { + member: _, + arguments: _, + } => { + let index = self.adt_index(ty)?; + let wt = self.own(&format!("__wt_{index}")); + Ok(self.b.app(wt, arg)) + } + SemanticType::Function { + parameters: _, + result: _, + } + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } => Err(format!( + "`{}` crosses no root boundary", + self.gen.source.type_text(ty) + )), + } + } + + fn wt_list(&mut self, element: &SemanticType, arg: Term) -> Result { + let (p, c, a) = (self.p, self.c, self.a); + let alpha = self.lean_type(element)?; + let e = self.encoder(element)?; + let t = self.encoded_ty(element)?; + let h = self.wt_function(element)?; + self.rust_lemma( + "wt_encList", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(alpha), + Arg::Term(e), + Arg::Term(t), + Arg::Term(h), + Arg::Term(arg), + ], + ) + } + + fn wt_pair( + &mut self, + left: &SemanticType, + right: &SemanticType, + arg: Term, + ) -> Result { + let (p, c, a) = (self.p, self.c, self.a); + let alpha = self.lean_type(left)?; + let beta = self.lean_type(right)?; + let ea = self.encoder(left)?; + let eb = self.encoder(right)?; + let s = self.encoded_ty(left)?; + let t = self.encoded_ty(right)?; + let ha = self.wt_function(left)?; + let hb = self.wt_function(right)?; + self.rust_lemma( + "wt_encPair", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(alpha), + Arg::Term(beta), + Arg::Term(ea), + Arg::Term(eb), + Arg::Term(s), + Arg::Term(t), + Arg::Term(ha), + Arg::Term(hb), + Arg::Term(arg), + ], + ) + } + + /// `fun (x : ty) => wt_apply ty x`: the well-typedness proof of every + /// value of a type, which the container lemmas take. + fn wt_function(&mut self, ty: &SemanticType) -> Result { + let domain = self.lean_type(ty)?; + let x = self.b.bvar(0); + let body = self.wt_apply(ty, x)?; + Ok(self.b.lam("__x", CoreBinderInfo::Explicit, domain, body)) + } + + /// `WTL p c A [v₁, …] [t₁, …]` from the proofs `WT p c A vᵢ tᵢ`: the + /// `wtl_cons` chain the text writes, with the values and types each cons + /// states. + fn wtl(&mut self, items: &[(Term, Term, Term)]) -> Result { + let (p, c, a) = (self.p, self.c, self.a); + let value_ty = self.syntax("Value"); + let ty_ty = self.syntax("Ty"); + let mut proof = self.rust_lemma("wtl_nil", &[Arg::Term(p), Arg::Term(c), Arg::Term(a)])?; + let mut values: Vec = Vec::new(); + let mut types: Vec = Vec::new(); + for &(value, ty, h) in items.iter().rev() { + let vs = self.b.list(value_ty, &values); + let ts = self.b.list(ty_ty, &types); + proof = self.rust_lemma( + "wtl_cons", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(value), + Arg::Term(ty), + Arg::Term(vs), + Arg::Term(ts), + Arg::Term(h), + Arg::Term(proof), + ], + )?; + values.insert(0, value); + types.insert(0, ty); + } + Ok(proof) + } + + /// `WT p c A value (Ty.adt index)`. + fn wt_statement(&mut self, value: Term, index: u64) -> Term { + let wt = self.rust("WT"); + let adt = self.syntax("Ty.adt"); + let index = self.b.nat(index); + let adt = self.b.app(adt, index); + let (p, c, a) = (self.p, self.c, self.a); + self.b.apps(wt, &[p, c, a, value, adt]) + } + + /// `wt_adt` for constructor `constructor` of ADT `index`, whose fields + /// are `fields` (type and the term holding the value), the fields' + /// well-typedness proven by [`Self::wt_apply`]. + fn wt_adt( + &mut self, + index: u64, + constructor: u64, + fields: &[(SemanticType, Term)], + ) -> Result { + let mut items = Vec::new(); + for (ty, value) in fields { + let encoded = self.encode(ty, *value)?; + let target = self.encoded_ty(ty)?; + let proof = self.wt_apply(ty, *value)?; + items.push((encoded, target, proof)); + } + self.wt_adt_items(index, constructor, &items) + } + + /// The row `__wt_k` of a document type `index` outside every recursive + /// group: every value of the type encodes to a well-typed value of + /// `Ty.adt index`, by the projections of a structure or by cases on an + /// inductive. + fn wt_row(&mut self, index: u64) -> Result { + let adt = &self.gen.layout.adts[index as usize]; + let ty = adt.ty.clone(); + let shape = self.gen.source.document(&ty)?; + let lean = self.lean_type(&ty)?; + let (member, arguments) = match &ty { + SemanticType::Named { member, arguments } => (member.clone(), arguments.clone()), + SemanticType::Type + | SemanticType::Parameter { name: _ } + | SemanticType::Nat + | SemanticType::Bool + | SemanticType::Prop + | SemanticType::Unit + | SemanticType::Int + | SemanticType::Int8 + | SemanticType::Int16 + | SemanticType::Int32 + | SemanticType::Int64 + | SemanticType::UInt8 + | SemanticType::UInt16 + | SemanticType::UInt32 + | SemanticType::UInt64 + | SemanticType::String + | SemanticType::Bytes + | SemanticType::Ordering + | SemanticType::Option { value: _ } + | SemanticType::Result { ok: _, error: _ } + | SemanticType::List { element: _ } + | SemanticType::Product { left: _, right: _ } + | SemanticType::Function { + parameters: _, + result: _, + } + | SemanticType::Map { key: _, value: _ } + | SemanticType::Set { element: _ } + | SemanticType::ContractViolation + | SemanticType::ReasoningFailure => { + return Err("an ADT of the layout that is not a document type".to_owned()); + } + }; + let owner = self.document_name(&member)?; + let binder = if shape.kind == "inductive" { + "__v" + } else { + "__s" + }; + // The statement: ∀ (v : T), WT p c A (A.__enc_k v) (.adt k). + let v = self.b.bvar(0); + let encoder = self.of_a(&format!("__enc_{index}")); + let encoded = self.b.app(encoder, v); + let body = self.wt_statement(encoded, index); + let statement = self.b.pi(binder, CoreBinderInfo::Explicit, lean, body); + let value = if shape.kind == "inductive" { + // By cases on the value: T.casesOn params motive v minors. + let motive = self.b.lam(binder, CoreBinderInfo::Explicit, lean, body); + let mut params = Vec::new(); + for argument in &arguments { + params.push(self.lean_type(argument)?); + } + let mut minors = Vec::new(); + for (constructor, fields) in shape.fields.iter().enumerate() { + let count = fields.len(); + let mut field_values = Vec::new(); + for (position, field) in fields.iter().enumerate() { + let var = self.b.bvar(count - 1 - position); + field_values.push((field.clone(), var)); + } + let mut minor = self.wt_adt(index, constructor as u64, &field_values)?; + for (position, field) in fields.iter().enumerate().rev() { + let domain = self.lean_type(field)?; + // The binder types are closed, so they need no lifting + // under the earlier binders. + minor = self.b.lam( + &format!("__x{position}"), + CoreBinderInfo::Explicit, + domain, + minor, + ); + } + minors.push(minor); + } + let cases_on = self.b.konst0(&format!("{owner}.casesOn")); + let mut args = params; + args.push(motive); + args.push(v); + args.extend(minors); + let cases = self.b.apps(cases_on, &args); + self.b.lam(binder, CoreBinderInfo::Explicit, lean, cases) + } else { + // A structure: its fields are the projections of the value. + let mut params = Vec::new(); + for argument in &arguments { + params.push(self.lean_type(argument)?); + } + let mut field_values = Vec::new(); + for (name, field) in shape.field_names.iter().zip(&shape.fields[0]) { + let projection = self.b.konst(&format!("{owner}.{name}")); + let projection = self.b.apps(projection, ¶ms); + let value = self.b.app(projection, v); + field_values.push((field.clone(), value)); + } + let proof = self.wt_adt(index, 0, &field_values)?; + self.b.lam(binder, CoreBinderInfo::Explicit, lean, proof) + }; + let name = format!("{}.__wt_{index}", self.name); + let axioms = self.axioms()?; + Ok(Row { + name, + ty: statement, + value, + axioms, + }) + } + + /// The axioms of the row being built: those of the library lemmas it + /// applies and of the module's own rows it references, read from the + /// library registry. + fn axioms(&mut self) -> Result, String> { + let mut out = BTreeSet::new(); + for lemma in self.b.take_lemmas() { + out.extend(preserve::library_axioms(&lemma)?); + } + for reference in self.take_references() { + if let Some(axioms) = self.row_axioms.get(&reference) { + out.extend(axioms.iter().cloned()); + } + } + Ok(out) + } + + // --- The root --------------------------------------------------------- + + /// The row `root`: the crate's root (or its boundary entry), invoked on + /// the encoded arguments, realizes certificate A's observation. + fn root_row( + &mut self, + root_module: &str, + root_name: &str, + fallible: bool, + ) -> Result { + let (parameters, result) = self.gen.source.signature(root_module, root_name, &[])?; + let count = parameters.len(); + // The parameters are the binders x₀ … xₙ₋₁, then __e_hrep: under all + // of them, xᵢ is #(n - i) and __e_hrep is #0. + let mut domains = Vec::new(); + let mut args = Vec::new(); + let mut wt_items = Vec::new(); + let mut applied_names = Vec::new(); + for (position, SemanticParameter { name, r#type }) in parameters.iter().enumerate() { + domains.push(self.lean_type(r#type)?); + let var = self.b.bvar(count - position); + let encoded = self.encode(r#type, var)?; + let target = self.encoded_ty(r#type)?; + let proof = self.wt_apply(r#type, var)?; + args.push(encoded); + wt_items.push((encoded, target, proof)); + applied_names.push((name.clone(), var)); + } + let value_ty = self.syntax("Value"); + let args_list = self.b.list(value_ty, &args); + let (p, c, a) = (self.p, self.c, self.a); + let (entry, env) = match self.gen.entry_of() { + Some((entry, _)) => (entry, self.environment(entry, &args)?), + None => (0, self.environment(0, &args)?), + }; + let fallible_term = self + .b + .konst(if fallible { "Bool.true" } else { "Bool.false" }); + let vars: Vec = applied_names.iter().map(|(_, var)| *var).collect(); + // The function the crate's root is, `fn` of `compose`: the entry of + // the program, read out of the program's function list. + let function_ty = self.syntax("Function"); + let functions = self.syntax("Program.functions"); + let functions = self.b.app(functions, p); + let entry_index = self.b.nat(entry); + let default_function = self.default_function(); + let get_d = self.b.konst0("List.getD"); + let function = self.b.apps( + get_d, + &[function_ty, functions, entry_index, default_function], + ); + // hB : ∀ n, FunSem p c A n f, from certificate B's root theorem. + let nat = self.b.konst("Nat"); + let b_root = self.b.konst(&format!("{}.root", self.module_b)); + let n = self.b.bvar(0); + let entry_lifted = self.b.nat(entry); + let hb_body = self.b.apps(b_root, &[n, entry_lifted]); + let hb = self.b.lam("__e_n", CoreBinderInfo::Explicit, nat, hb_body); + let hwt = self.wtl(&wt_items)?; + let is_entry = self.gen.entry_of().is_some(); + let (observation, fits, outcome, h_a) = if is_entry { + let denote_entry = self.of_a("denoteEntry"); + let observation = self.b.apps(denote_entry, &vars); + let entry_fits = self.of_a("entryFits"); + let fits = self.b.apps(entry_fits, &vars); + let entry_value = self.of_a("entryValue"); + let outcome = self.b.apps(entry_value, &vars); + let entry_theorem = self.of_a("entry"); + let h_a = self.b.apps(entry_theorem, &vars); + (observation, fits, outcome, h_a) + } else { + let denote = self.of_a("denote"); + let observation = self.b.apps(denote, &vars); + let fits_0 = self.of_a("__fits_0"); + let fits = self.b.apps(fits_0, &vars); + let root_lean = self.gen.source.lean_name( + root_module, + &MemberRef { + module: Some(root_module.to_owned()), + name: root_name.to_owned(), + }, + ); + let root_fn = self.b.konst(&root_lean); + let applied = self.b.apps(root_fn, &vars); + let outcome = self.encode(&result, applied)?; + let a_root = self.of_a("root"); + let h_a = self.b.apps(a_root, &vars); + (observation, fits, outcome, h_a) + }; + let hne = self.rust_lemma("rel_ne_stuck", &[Arg::Term(fits), Arg::Term(outcome)])?; + let composed = self.rust_lemma( + "compose", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(entry_index), + Arg::Term(function), + Arg::Term(args_list), + Arg::Term(env), + Arg::Term(fallible_term), + Arg::Term(observation), + Arg::Term(hb), + Arg::Refl, + Arg::Term(hwt), + Arg::Refl, + Arg::Refl, + Arg::Term(h_a), + Arg::Term(hne), + ], + )?; + // The statement and, for an entry, the proof that reshapes compose's + // conclusion by the entry's two equations. + let r_out = self.rust("ROut"); + let realizes = self.rust("RealizesFn"); + let rci = self.rust("RCI"); + let fn_ident = self.rust("fnIdent"); + let ident = self.b.app(fn_ident, entry_index); + let and = self.b.konst("And"); + let exists = self.b.konst1("Exists"); + let (statement_body, proof) = if is_entry { + let rci_term = { + let ro = self.b.bvar(0); + let lifted_args = self.b.lift(args_list, 1, 0); + self.b.apps(rci, &[c, ident, lifted_args, ro]) + }; + let accepts = self.of_a("accepts"); + let accepted = self.b.apps(accepts, &vars); + let some_obs = self.library("someObs"); + let denote = self.of_a("denote"); + let denoted = self.b.apps(denote, &vars); + let accepted_obs = self.b.app(some_obs, denoted); + let obs_value = self.library("Obs.value"); + let none = self.syntax("Value.none"); + let refused_obs = self.b.app(obs_value, none); + let not = self.b.konst("Not"); + let refused = self.b.app(not, accepted); + // Under the binder ro (#0): the two implications, whose bodies + // are under one more anonymous binder. + let body = { + let ro = self.b.bvar(0); + let accepted1 = self.b.lift(accepted, 1, 0); + let accepted_obs1 = self.b.lift(accepted_obs, 1, 0); + let refused1 = self.b.lift(refused, 1, 0); + let refused_obs1 = self.b.lift(refused_obs, 1, 0); + let realizes_accepted = { + let ro1 = self.b.bvar(1); + let f = fallible_term; + let obs = self.b.lift(accepted_obs1, 1, 0); + self.b.apps(realizes, &[f, obs, ro1]) + }; + let implies_accepted = + self.b + .pi("", CoreBinderInfo::Explicit, accepted1, realizes_accepted); + let realizes_refused = { + let ro1 = self.b.bvar(1); + let f = fallible_term; + let obs = self.b.lift(refused_obs1, 1, 0); + self.b.apps(realizes, &[f, obs, ro1]) + }; + let implies_refused = + self.b + .pi("", CoreBinderInfo::Explicit, refused1, realizes_refused); + let tail = self.b.apps(and, &[implies_accepted, implies_refused]); + let _ = ro; + self.b.apps(and, &[rci_term, tail]) + }; + let predicate = self.b.lam("__e_ro", CoreBinderInfo::Explicit, r_out, body); + let statement = self.b.apps(exists, &[r_out, predicate]); + // The proof: from compose's ⟨ro, hr, hc⟩ build ⟨ro, hc, _, _⟩, + // each implication rewriting hr by the entry's equation. + let compose_predicate = { + let ro = self.b.bvar(0); + let lifted_args = self.b.lift(args_list, 1, 0); + let realizes_obs = { + let obs = self.b.lift(observation, 1, 0); + self.b.apps(realizes, &[fallible_term, obs, ro]) + }; + let rci_ro = self.b.apps(rci, &[c, ident, lifted_args, ro]); + let conj = self.b.apps(and, &[realizes_obs, rci_ro]); + self.b.lam("__e_ro", CoreBinderInfo::Explicit, r_out, conj) + }; + let proof = { + // fun (ro : ROut) (hand : RealizesFn F obs ro ∧ RCI …) => … + let ro = self.b.bvar(1); + let hand = self.b.bvar(0); + let obs2 = self.b.lift(observation, 2, 0); + let args2 = self.b.lift(args_list, 2, 0); + let realizes_obs = self.b.apps(realizes, &[fallible_term, obs2, ro]); + let rci_ro = self.b.apps(rci, &[c, ident, args2, ro]); + let and_left = self.b.konst("And.left"); + let and_right = self.b.konst("And.right"); + let hr = self.b.apps(and_left, &[realizes_obs, rci_ro, hand]); + let hc = self.b.apps(and_right, &[realizes_obs, rci_ro, hand]); + let obs_ty = self.library("Obs"); + let motive = { + // Under o: hand is #1 and ro is #2. + let o = self.b.bvar(0); + let ro2 = self.b.bvar(2); + let body = self.b.apps(realizes, &[fallible_term, o, ro2]); + self.b.lam("__e_o", CoreBinderInfo::Explicit, obs_ty, body) + }; + let eq_subst = self.b.konst1("Eq.subst"); + let accepted2 = self.b.lift(accepted, 2, 0); + let accepted_obs2 = self.b.lift(accepted_obs, 2, 0); + let refused2 = self.b.lift(refused, 2, 0); + let refused_obs2 = self.b.lift(refused_obs, 2, 0); + let vars3: Vec = vars.iter().map(|&var| self.b.lift(var, 3, 0)).collect(); + let accepted_proof = { + let h = self.b.bvar(0); + let entry_accepts = self.of_a("entry_accepts"); + let mut equation_args = vars3.clone(); + equation_args.push(h); + let equation = self.b.apps(entry_accepts, &equation_args); + let obs3 = self.b.lift(observation, 3, 0); + let target = self.b.lift(accepted_obs, 3, 0); + let hr3 = self.b.lift(hr, 1, 0); + let motive3 = self.b.lift(motive, 1, 0); + let rewritten = self + .b + .apps(eq_subst, &[obs_ty, motive3, obs3, target, equation, hr3]); + self.b + .lam("__e_h", CoreBinderInfo::Explicit, accepted2, rewritten) + }; + let refused_proof = { + let h = self.b.bvar(0); + let entry_refuses = self.of_a("entry_refuses"); + let mut equation_args = vars3.clone(); + equation_args.push(h); + let equation = self.b.apps(entry_refuses, &equation_args); + let obs3 = self.b.lift(observation, 3, 0); + let target = self.b.lift(refused_obs, 3, 0); + let hr3 = self.b.lift(hr, 1, 0); + let motive3 = self.b.lift(motive, 1, 0); + let rewritten = self + .b + .apps(eq_subst, &[obs_ty, motive3, obs3, target, equation, hr3]); + self.b + .lam("__e_h", CoreBinderInfo::Explicit, refused2, rewritten) + }; + let and_intro = self.b.konst("And.intro"); + let realizes_accepted2 = self.b.apps(realizes, &[fallible_term, accepted_obs2, ro]); + let realizes_refused2 = self.b.apps(realizes, &[fallible_term, refused_obs2, ro]); + let implies_accepted2 = { + let lifted = self.b.lift(realizes_accepted2, 1, 0); + self.b.pi("", CoreBinderInfo::Explicit, accepted2, lifted) + }; + let implies_refused2 = { + let lifted = self.b.lift(realizes_refused2, 1, 0); + self.b.pi("", CoreBinderInfo::Explicit, refused2, lifted) + }; + let tail_ty = self.b.apps(and, &[implies_accepted2, implies_refused2]); + let tail = self.b.apps( + and_intro, + &[ + implies_accepted2, + implies_refused2, + accepted_proof, + refused_proof, + ], + ); + let witness = self.b.apps(and_intro, &[rci_ro, tail_ty, hc, tail]); + let exists_intro = self.b.konst1("Exists.intro"); + let predicate2 = self.b.lift(predicate, 2, 0); + let intro = self.b.apps(exists_intro, &[r_out, predicate2, ro, witness]); + let hand_ty = self.b.apps(and, &[realizes_obs, rci_ro]); + let hand_ty = { + // hand's type is stated under ro only. + let ro1 = self.b.bvar(0); + let obs1 = self.b.lift(observation, 1, 0); + let args1 = self.b.lift(args_list, 1, 0); + let realizes1 = self.b.apps(realizes, &[fallible_term, obs1, ro1]); + let rci1 = self.b.apps(rci, &[c, ident, args1, ro1]); + let _ = hand_ty; + self.b.apps(and, &[realizes1, rci1]) + }; + let inner = self + .b + .lam("__e_hand", CoreBinderInfo::Explicit, hand_ty, intro); + let elim_fn = self.b.lam("__e_ro", CoreBinderInfo::Explicit, r_out, inner); + let exists_elim = self.b.konst1("Exists.elim"); + self.b.apps( + exists_elim, + &[r_out, compose_predicate, statement, composed, elim_fn], + ) + }; + (statement, proof) + } else { + let body = { + let ro = self.b.bvar(0); + let obs1 = self.b.lift(observation, 1, 0); + let args1 = self.b.lift(args_list, 1, 0); + let realizes_obs = self.b.apps(realizes, &[fallible_term, obs1, ro]); + let rci_ro = self.b.apps(rci, &[c, ident, args1, ro]); + self.b.apps(and, &[realizes_obs, rci_ro]) + }; + let predicate = self.b.lam("__e_ro", CoreBinderInfo::Explicit, r_out, body); + let statement = self.b.apps(exists, &[r_out, predicate]); + (statement, composed) + }; + // Close the binders: the parameters, then __e_hrep, whose type is + // stated under the parameters alone, one binder above the body. + let representable = self.rust("RepresentableL"); + let mut outer_args = Vec::new(); + for (position, SemanticParameter { name: _, r#type }) in parameters.iter().enumerate() { + let var = self.b.bvar(count - 1 - position); + outer_args.push(self.encode(r#type, var)?); + } + let outer_args = self.b.list(value_ty, &outer_args); + let hrep_ty = self.b.app(representable, outer_args); + let mut statement = self.b.pi( + "__e_hrep", + CoreBinderInfo::Explicit, + hrep_ty, + statement_body, + ); + let mut value = self + .b + .lam("__e_hrep", CoreBinderInfo::Explicit, hrep_ty, proof); + for (position, SemanticParameter { name, r#type: _ }) in parameters.iter().enumerate().rev() + { + let domain = domains[position]; + let binder = binder_name(name); + statement = self + .b + .pi(&binder, CoreBinderInfo::Explicit, domain, statement); + value = self.b.lam(&binder, CoreBinderInfo::Explicit, domain, value); + } + let mut axioms = self.axioms()?; + // Certificates A and B are audited to exactly the certificate axioms, + // which the composition therefore carries. + axioms.extend(CERTIFICATE_AXIOMS.iter().map(|axiom| (*axiom).to_owned())); + Ok(Row { + name: format!("{}.root", self.name), + ty: statement, + value, + axioms, + }) + } + + /// The environment `bindAll parameters args []` yields: the parameters + /// bound to the arguments, the last binding first. + fn environment(&mut self, function: u64, args: &[Term]) -> Result { + let parameters = &self + .gen + .program + .functions + .get(function as usize) + .ok_or_else(|| format!("the program has no function {function}"))? + .parameters; + if parameters.len() != args.len() { + return Err(format!( + "function {function} takes {} parameters, the root {} arguments", + parameters.len(), + args.len() + )); + } + let nat = self.b.konst("Nat"); + let value_ty = self.syntax("Value"); + let entry_ty = self.b.pair_ty(nat, value_ty); + let mut bindings = Vec::new(); + for (parameter, arg) in parameters.iter().zip(args).rev() { + let name = self.b.nat(*parameter); + bindings.push(self.b.pair(nat, value_ty, name, *arg)); + } + Ok(self.b.list(entry_ty, &bindings)) + } + + /// A function of the target calculus, as `List.getD`'s fallback: never + /// read, since the entry is in the list. + fn default_function(&mut self) -> Term { + let nat = self.b.konst("Nat"); + let ty_ty = self.syntax("Ty"); + let parameters = self.b.list(nat, &[]); + let types = self.b.list(ty_ty, &[]); + let unit_ty = self.syntax("Ty.unit"); + let unit_value = self.syntax("Value.unit"); + let value_expr = self.syntax("Expr.value"); + let body = self.b.apps(value_expr, &[unit_ty, unit_value]); + let mk = self.syntax("Function.mk"); + self.b.apps(mk, &[parameters, types, unit_ty, body]) + } + + /// The module: the well-typedness rows in dependency order, then `root`. + fn module( + mut self, + root_module: &str, + root_name: &str, + fallible: bool, + ) -> Result { + let graph = self.gen.adt_graph()?; + let mut rows = Vec::new(); + for component in components(&graph) { + let recursive = component.len() > 1 + || component.iter().any(|index| { + self.gen + .nested + .values() + .any(|nested| nested.group == *index) + || graph.get(index).is_some_and(|edges| edges.contains(index)) + }); + let built = if recursive { + self.group_rows(&component)? + } else { + let mut built = Vec::new(); + for index in component { + built.push(self.wt_row(index)?); + } + built + }; + for row in built { + self.row_axioms.insert(row.name.clone(), row.axioms.clone()); + rows.push(row); + } + } + rows.push(self.root_row(root_module, root_name, fallible)?); + // Every row is closed: a loose variable is a generator error, named + // here rather than by the kernel. + for row in &rows { + if self.b.has_loose(row.ty, 0) || self.b.has_loose(row.value, 0) { + return Err(format!( + "the row `{}` of certificate E has a loose bound variable", + row.name + )); + } + } + let declarations = rows + .into_iter() + .map(|row| theorem_row(row.name, row.ty, row.value, &row.axioms)) + .collect(); + let module = CoreModule { + spec: CORE_SPEC_2.to_owned(), + imports: vec![ + self.module_a.clone(), + self.module_b.clone(), + COMPOSE_MODULE.to_owned(), + ], + nodes: self.b.finish(), + proof_nodes: Vec::new(), + declarations, + }; + module.validate(crate::LANGUAGE_1_2)?; + Ok(module) + } +} + +/// A container the kernel nests in a recursive group of document types: an +/// auxiliary inductive type of the group's recursors, with its own motive. +struct Aux { + /// The container as the source writes it, which certificate A's nested + /// auxiliary encoder is registered under. + original: SemanticType, + /// The container as Lean sees it: a set as a list, a map as a list of + /// pairs. + canonical: SemanticType, + kind: AuxKind, + /// Certificate A's auxiliary for the container (`__items_n`, `__aux_n`). + nested_index: u64, +} + +#[derive(Clone, Copy, PartialEq, Eq)] +enum AuxKind { + List, + Option, + Prod, + Except, +} + +/// Where a type stands among the motives of a group's recursors. +#[derive(Clone, Copy)] +enum Position { + Block(usize), + Aux(usize), +} + +/// A recursive group: its document types in Lean's declaration order (the +/// order of the mutual block) and the containers nested in them, in the +/// order the kernel creates their auxiliary types: every nested container of +/// the block's constructors, then those found inside the auxiliaries, each in +/// turn. +struct Group { + block: Vec, + aux: Vec, +} + +/// A type as Lean's kernel sees it: a set is a list, a map a list of pairs, +/// a contract violation or reasoning failure a pair of Booleans. +fn canonical(ty: &SemanticType) -> SemanticType { + match ty { + SemanticType::Set { element } | SemanticType::List { element } => SemanticType::List { + element: Box::new(canonical(element)), + }, + SemanticType::Map { key, value } => SemanticType::List { + element: Box::new(SemanticType::Product { + left: Box::new(canonical(key)), + right: Box::new(canonical(value)), + }), + }, + SemanticType::ContractViolation | SemanticType::ReasoningFailure => SemanticType::Product { + left: Box::new(SemanticType::Bool), + right: Box::new(SemanticType::Bool), + }, + SemanticType::Option { value } => SemanticType::Option { + value: Box::new(canonical(value)), + }, + SemanticType::Product { left, right } => SemanticType::Product { + left: Box::new(canonical(left)), + right: Box::new(canonical(right)), + }, + SemanticType::Result { ok, error } => SemanticType::Result { + ok: Box::new(canonical(ok)), + error: Box::new(canonical(error)), + }, + SemanticType::Named { member, arguments } => SemanticType::Named { + member: member.clone(), + arguments: arguments.iter().map(canonical).collect(), + }, + SemanticType::Function { + parameters: _, + result: _, + } + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } + | SemanticType::Nat + | SemanticType::Bool + | SemanticType::Unit + | SemanticType::Int + | SemanticType::Int8 + | SemanticType::Int16 + | SemanticType::Int32 + | SemanticType::Int64 + | SemanticType::UInt8 + | SemanticType::UInt16 + | SemanticType::UInt32 + | SemanticType::UInt64 + | SemanticType::String + | SemanticType::Bytes + | SemanticType::Ordering => ty.clone(), + } +} + +/// One field of a constructor as a minor premise sees it: its type, the +/// variable holding it, and its induction hypothesis when it is recursive. +struct Field { + ty: SemanticType, + var: Term, + hypothesis: Option, +} + +impl Composer<'_, '_> { + /// The recursive group of one strongly connected component of the ADT + /// graph. + fn group(&self, component: &[u64]) -> Result { + let mut ordered = Vec::new(); + for &index in component { + let ty = &self.gen.layout.adts[index as usize].ty; + let member = named_member(ty)?; + let module = member.module.clone().ok_or("an unanchored document type")?; + let position = self + .gen + .source + .declaration_position(&module, &member.name) + .ok_or_else(|| format!("`{}` is not declared in `{module}`", member.name))?; + ordered.push((position, index)); + } + ordered.sort_unstable(); + let block: Vec = ordered.into_iter().map(|(_, index)| index).collect(); + let block_keys: BTreeSet = block + .iter() + .map(|&index| self.key(&self.gen.layout.adts[index as usize].ty)) + .collect(); + let mut aux: Vec = Vec::new(); + let mut seen: BTreeSet = BTreeSet::new(); + for &index in &block { + let shape = self + .gen + .source + .document(&self.gen.layout.adts[index as usize].ty)?; + for fields in &shape.fields { + for field in fields { + self.register_aux(field, &block_keys, &mut aux, &mut seen)?; + } + } + } + let mut next = 0; + while next < aux.len() { + for field in self.aux_fields(&aux[next])? { + self.register_aux(&field, &block_keys, &mut aux, &mut seen)?; + } + next += 1; + } + Ok(Group { block, aux }) + } + + /// The key of a type among a group's positions: its canonical spelling as + /// Lean sees it. + fn key(&self, ty: &SemanticType) -> String { + self.gen.source.type_text(&canonical(ty)) + } + + /// Whether a canonical type mentions a type of the block. + fn mentions(&self, ty: &SemanticType, block_keys: &BTreeSet) -> bool { + match ty { + SemanticType::Named { + member: _, + arguments: _, + } => block_keys.contains(&self.gen.source.type_text(ty)), + SemanticType::List { element } | SemanticType::Option { value: element } => { + self.mentions(element, block_keys) + } + SemanticType::Product { left, right } + | SemanticType::Result { + ok: left, + error: right, + } => self.mentions(left, block_keys) || self.mentions(right, block_keys), + SemanticType::Set { element: _ } + | SemanticType::Map { key: _, value: _ } + | SemanticType::ContractViolation + | SemanticType::ReasoningFailure + | SemanticType::Function { + parameters: _, + result: _, + } + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } + | SemanticType::Nat + | SemanticType::Bool + | SemanticType::Unit + | SemanticType::Int + | SemanticType::Int8 + | SemanticType::Int16 + | SemanticType::Int32 + | SemanticType::Int64 + | SemanticType::UInt8 + | SemanticType::UInt16 + | SemanticType::UInt32 + | SemanticType::UInt64 + | SemanticType::String + | SemanticType::Bytes + | SemanticType::Ordering => false, + } + } + + /// Register the container `original` as an auxiliary of the group when + /// it nests a type of the block and is not yet registered. + fn register_aux( + &self, + original: &SemanticType, + block_keys: &BTreeSet, + aux: &mut Vec, + seen: &mut BTreeSet, + ) -> Result<(), String> { + let canonical = canonical(original); + if !self.mentions(&canonical, block_keys) { + return Ok(()); + } + let kind = match &canonical { + SemanticType::List { element: _ } => AuxKind::List, + SemanticType::Option { value: _ } => AuxKind::Option, + SemanticType::Product { left: _, right: _ } => AuxKind::Prod, + SemanticType::Result { ok: _, error: _ } => AuxKind::Except, + SemanticType::Named { + member: _, + arguments: _, + } => return Ok(()), + SemanticType::Set { element: _ } + | SemanticType::Map { key: _, value: _ } + | SemanticType::ContractViolation + | SemanticType::ReasoningFailure + | SemanticType::Function { + parameters: _, + result: _, + } + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } + | SemanticType::Nat + | SemanticType::Bool + | SemanticType::Unit + | SemanticType::Int + | SemanticType::Int8 + | SemanticType::Int16 + | SemanticType::Int32 + | SemanticType::Int64 + | SemanticType::UInt8 + | SemanticType::UInt16 + | SemanticType::UInt32 + | SemanticType::UInt64 + | SemanticType::String + | SemanticType::Bytes + | SemanticType::Ordering => return Ok(()), + }; + let key = self.gen.source.type_text(&canonical); + if !seen.insert(key) { + return Ok(()); + } + let text = self.gen.source.type_text(original); + let nested_index = self + .gen + .nested + .get(&text) + .map(|nested| nested.index) + .ok_or_else(|| { + format!("`{text}` is nested in a recursive group, but certificate A has no auxiliary encoder for it") + })?; + aux.push(Aux { + original: original.clone(), + canonical, + kind, + nested_index, + }); + Ok(()) + } + + /// The field types of an auxiliary's constructors other than itself: the + /// element of a list, the value of an option, the components of a pair, + /// the error and the value of a result. + fn aux_fields(&self, aux: &Aux) -> Result, String> { + let parts = container_parts(&aux.original)?; + let expected = match aux.kind { + AuxKind::List | AuxKind::Option => 1, + AuxKind::Prod | AuxKind::Except => 2, + }; + if parts.len() != expected { + return Err(format!( + "`{}` is an auxiliary of the wrong shape", + self.gen.source.type_text(&aux.original) + )); + } + Ok(parts) + } + + /// The position of a type among the group's motives, if it has one. + fn position(&self, group: &Group, ty: &SemanticType) -> Option { + let key = self.key(ty); + if let Some(index) = group + .block + .iter() + .position(|&index| self.key(&self.gen.layout.adts[index as usize].ty) == key) + { + return Some(Position::Block(index)); + } + group + .aux + .iter() + .position(|aux| self.gen.source.type_text(&aux.canonical) == key) + .map(Position::Aux) + } + + /// The body of a motive, over `#0` for the value: the statement each + /// row of the group proves. + fn motive_body(&mut self, group: &Group, position: Position) -> Result { + let v = self.b.bvar(0); + match position { + Position::Block(block_position) => { + let index = group.block[block_position]; + let encoder = self.of_a(&format!("__enc_{index}")); + let encoded = self.b.app(encoder, v); + Ok(self.wt_statement(encoded, index)) + } + Position::Aux(aux_position) => { + let aux = &group.aux[aux_position]; + let n = aux.nested_index; + let (p, c, a) = (self.p, self.c, self.a); + match aux.kind { + AuxKind::List => { + let element = super::element_of(&aux.original)?; + let items = self.of_a(&format!("__items_{n}")); + let items = self.b.app(items, v); + let t = self.encoded_ty(&element)?; + let wt_all = self.rust("WTAll"); + Ok(self.b.apps(wt_all, &[p, c, a, items, t])) + } + AuxKind::Option | AuxKind::Prod | AuxKind::Except => { + let aux_encoder = self.of_a(&format!("__aux_{n}")); + let encoded = self.b.app(aux_encoder, v); + let t = self.encoded_ty(&aux.original.clone())?; + let wt = self.rust("WT"); + Ok(self.b.apps(wt, &[p, c, a, encoded, t])) + } + } + } + } + } + + /// The Lean type of the values a position's motive ranges over. + fn position_type(&mut self, group: &Group, position: Position) -> Result { + match position { + Position::Block(block_position) => { + let ty = self.gen.layout.adts[group.block[block_position] as usize] + .ty + .clone(); + self.lean_type(&ty) + } + Position::Aux(aux_position) => { + let ty = group.aux[aux_position].canonical.clone(); + self.lean_type(&ty) + } + } + } + + /// The well-typedness proof of a field inside a minor premise: its + /// induction hypothesis when it is recursive, else the proof of + /// [`Self::wt_apply`]. + fn wt_field(&mut self, group: &Group, field: &Field) -> Result { + let Some(hypothesis) = field.hypothesis else { + return self.wt_apply(&field.ty, field.var); + }; + match self.position(group, &field.ty) { + Some(Position::Aux(aux_position)) if group.aux[aux_position].kind == AuxKind::List => { + let n = group.aux[aux_position].nested_index; + let element = super::element_of(&group.aux[aux_position].original)?; + let items = self.of_a(&format!("__items_{n}")); + let items = self.b.app(items, field.var); + let t = self.encoded_ty(&element)?; + let (p, c, a) = (self.p, self.c, self.a); + self.rust_lemma( + "wt_list", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(items), + Arg::Term(t), + Arg::Term(hypothesis), + ], + ) + } + Some(Position::Block(_) | Position::Aux(_)) => Ok(hypothesis), + None => Err(format!( + "`{}` has an induction hypothesis but no motive", + self.gen.source.type_text(&field.ty) + )), + } + } + + /// A minor premise: `fun fields… hypotheses… => body`, the hypotheses + /// for the recursive fields in field order, `body` built over the fields. + #[allow(clippy::type_complexity)] + fn minor( + &mut self, + group: &Group, + fields: &[SemanticType], + body: &dyn Fn(&mut Self, &[Field]) -> Result, + ) -> Result { + let positions: Vec> = fields + .iter() + .map(|field| self.position(group, field)) + .collect(); + let m = fields.len(); + let r = positions + .iter() + .filter(|position| position.is_some()) + .count(); + let mut bound = Vec::new(); + let mut k = 0; + for (j, field) in fields.iter().enumerate() { + let var = self.b.bvar(m + r - 1 - j); + let hypothesis = positions[j].map(|_| { + let term = self.b.bvar(r - 1 - k); + k += 1; + term + }); + bound.push(Field { + ty: field.clone(), + var, + hypothesis, + }); + } + let mut term = body(self, &bound)?; + // The hypotheses, innermost first: the k-th binds at depth m + k, + // where field j is #(m + k - 1 - j). + let recursive: Vec<(usize, Position)> = positions + .iter() + .enumerate() + .filter_map(|(j, position)| position.map(|position| (j, position))) + .collect(); + for (k, (j, position)) in recursive.iter().enumerate().rev() { + let var = self.b.bvar(m + k - 1 - j); + let motive = self.motive_body(group, *position)?; + let domain = self.b.instantiate(motive, var); + term = self + .b + .lam(&format!("__ih{k}"), CoreBinderInfo::Explicit, domain, term); + } + for (j, field) in fields.iter().enumerate().rev() { + let domain = self.lean_type(field)?; + term = self + .b + .lam(&format!("__x{j}"), CoreBinderInfo::Explicit, domain, term); + } + Ok(term) + } + + /// The minor premises of the group's recursors: the block's constructors + /// in order, then each auxiliary's. + fn minors(&mut self, group: &Group) -> Result, String> { + let mut out = Vec::new(); + for &index in &group.block { + let ty = self.gen.layout.adts[index as usize].ty.clone(); + let shape = self.gen.source.document(&ty)?; + for (constructor, fields) in shape.fields.iter().enumerate() { + let constructor = constructor as u64; + let minor = self.minor(group, fields, &|this, bound| { + let mut items = Vec::new(); + for field in bound { + let encoded = this.encode(&field.ty, field.var)?; + let target = this.encoded_ty(&field.ty)?; + let proof = this.wt_field(group, field)?; + items.push((encoded, target, proof)); + } + this.wt_adt_items(index, constructor, &items) + })?; + out.push(minor); + } + } + for aux_position in 0..group.aux.len() { + let aux = &group.aux[aux_position]; + let original = aux.original.clone(); + let n = aux.nested_index; + let (p, c, a) = (self.p, self.c, self.a); + match aux.kind { + AuxKind::List => { + let element = super::element_of(&original)?; + let t = self.encoded_ty(&element)?; + out.push(self.rust_lemma( + "wtAll_nil", + &[Arg::Term(p), Arg::Term(c), Arg::Term(a), Arg::Term(t)], + )?); + let fields = [element.clone(), original.clone()]; + out.push(self.minor(group, &fields, &|this, bound| { + let head = &bound[0]; + let tail = &bound[1]; + let v = this.encode(&head.ty, head.var)?; + let items = this.of_a(&format!("__items_{n}")); + let vs = this.b.app(items, tail.var); + let t = this.encoded_ty(&head.ty)?; + let h = this.wt_field(group, head)?; + let hs = tail + .hypothesis + .ok_or("a list auxiliary whose tail has no hypothesis")?; + this.rust_lemma( + "wtAll_cons", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(v), + Arg::Term(vs), + Arg::Term(t), + Arg::Term(h), + Arg::Term(hs), + ], + ) + })?); + } + AuxKind::Option => { + let inner = container_parts(&original)? + .pop() + .ok_or("an option auxiliary of a non-option")?; + let t = self.encoded_ty(&inner)?; + out.push(self.rust_lemma( + "wt_noneV", + &[Arg::Term(p), Arg::Term(c), Arg::Term(a), Arg::Term(t)], + )?); + let fields = [inner]; + out.push(self.minor(group, &fields, &|this, bound| { + let val = &bound[0]; + let v = this.encode(&val.ty, val.var)?; + let t = this.encoded_ty(&val.ty)?; + let h = this.wt_field(group, val)?; + this.rust_lemma( + "wt_someV", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(v), + Arg::Term(t), + Arg::Term(h), + ], + ) + })?); + } + AuxKind::Prod => { + let fields = self.aux_fields(aux)?; + out.push(self.minor(group, &fields, &|this, bound| { + let (left, right) = (&bound[0], &bound[1]); + let va = this.encode(&left.ty, left.var)?; + let vb = this.encode(&right.ty, right.var)?; + let s = this.encoded_ty(&left.ty)?; + let t = this.encoded_ty(&right.ty)?; + let ha = this.wt_field(group, left)?; + let hb = this.wt_field(group, right)?; + this.rust_lemma( + "wt_pairV", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(va), + Arg::Term(vb), + Arg::Term(s), + Arg::Term(t), + Arg::Term(ha), + Arg::Term(hb), + ], + ) + })?); + } + AuxKind::Except => { + let mut parts = container_parts(&original)?; + let ok = parts.pop().ok_or("a result auxiliary of a non-result")?; + let error = parts.pop().ok_or("a result auxiliary of a non-result")?; + let s = self.encoded_ty(&ok)?; + let t = self.encoded_ty(&error)?; + let error_fields = [error.clone()]; + out.push(self.minor(group, &error_fields, &|this, bound| { + let field = &bound[0]; + let v = this.encode(&field.ty, field.var)?; + let h = this.wt_field(group, field)?; + this.rust_lemma( + "wt_errorV", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(v), + Arg::Term(s), + Arg::Term(t), + Arg::Term(h), + ], + ) + })?); + let ok_fields = [ok.clone()]; + out.push(self.minor(group, &ok_fields, &|this, bound| { + let field = &bound[0]; + let v = this.encode(&field.ty, field.var)?; + let h = this.wt_field(group, field)?; + this.rust_lemma( + "wt_okV", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(v), + Arg::Term(s), + Arg::Term(t), + Arg::Term(h), + ], + ) + })?); + } + } + } + Ok(out) + } + + /// `wt_adt` from the encoded fields, their types, and their proofs. + fn wt_adt_items( + &mut self, + index: u64, + constructor: u64, + items: &[(Term, Term, Term)], + ) -> Result { + let value_ty = self.syntax("Value"); + let ty_ty = self.syntax("Ty"); + let fs: Vec = items.iter().map(|item| item.0).collect(); + let tys: Vec = items.iter().map(|item| item.1).collect(); + let fs = self.b.list(value_ty, &fs); + let tys = self.b.list(ty_ty, &tys); + let hf = self.wtl(items)?; + let (p, c, a) = (self.p, self.c, self.a); + let i = self.b.nat(index); + let k = self.b.nat(constructor); + self.rust_lemma( + "wt_adt", + &[ + Arg::Term(p), + Arg::Term(c), + Arg::Term(a), + Arg::Term(i), + Arg::Term(k), + Arg::Term(fs), + Arg::Term(tys), + Arg::Refl, + Arg::Term(hf), + ], + ) + } + + /// The rows of a recursive group: one per document type and one per + /// nested container, each the group's recursor at the motives and minor + /// premises the group shares (`T.rec` for a document type, `T.rec_j` of + /// the block's first type for the `j`-th auxiliary). + fn group_rows(&mut self, component: &[u64]) -> Result, String> { + let group = self.group(component)?; + let first = self.gen.layout.adts[group.block[0] as usize].ty.clone(); + let first_member = named_member(&first)?; + let first_arguments = type_arguments(&first); + let first_name = self.document_name(&first_member)?; + let mut params = Vec::new(); + for argument in &first_arguments { + params.push(self.lean_type(argument)?); + } + let mut positions: Vec = (0..group.block.len()).map(Position::Block).collect(); + positions.extend((0..group.aux.len()).map(Position::Aux)); + let mut motives = Vec::new(); + let mut bodies = Vec::new(); + for &position in &positions { + let domain = self.position_type(&group, position)?; + let body = self.motive_body(&group, position)?; + motives.push(self.b.lam("__v", CoreBinderInfo::Explicit, domain, body)); + bodies.push((domain, body)); + } + let minors = self.minors(&group)?; + let axioms = self.axioms()?; + let mut rows = Vec::new(); + for (ordinal, &position) in positions.iter().enumerate() { + let (domain, body) = bodies[ordinal]; + let (recursor, name) = match position { + Position::Block(block_position) => { + let index = group.block[block_position]; + let member = named_member(&self.gen.layout.adts[index as usize].ty)?; + let owner = self.document_name(&member)?; + (format!("{owner}.rec"), format!("__wt_{index}")) + } + Position::Aux(aux_position) => { + let aux = &group.aux[aux_position]; + let name = match aux.kind { + AuxKind::List => format!("__wtItems_{}", aux.nested_index), + AuxKind::Option | AuxKind::Prod | AuxKind::Except => { + format!("__wtAux_{}", aux.nested_index) + } + }; + (format!("{first_name}.rec_{}", aux_position + 1), name) + } + }; + let recursor = self.b.konst0(&recursor); + let v = self.b.bvar(0); + let mut args = params.clone(); + args.extend(motives.iter().copied()); + args.extend(minors.iter().copied()); + args.push(v); + let applied = self.b.apps(recursor, &args); + let value = self.b.lam("__v", CoreBinderInfo::Explicit, domain, applied); + let statement = self.b.pi("__v", CoreBinderInfo::Explicit, domain, body); + rows.push(Row { + name: format!("{}.{name}", self.name), + ty: statement, + value, + axioms: axioms.clone(), + }); + } + // Every auxiliary certificate A registered for the group has a row, + // or a proof somewhere else would name a theorem that is not there. + for nested in self.gen.nested.values() { + if component.contains(&nested.group) + && !group.aux.iter().any(|aux| aux.nested_index == nested.index) + { + return Err(format!( + "`{}` is an auxiliary of the group but the kernel nests no such type", + self.gen.source.type_text(&nested.ty) + )); + } + } + Ok(rows) + } +} + +/// The field types of a container's constructors other than the container +/// itself: the element of a list, set, or map (its entries), the value of an +/// option, the two components of a pair, and the error then the value of a +/// result. +fn container_parts(ty: &SemanticType) -> Result, String> { + Ok(match ty { + SemanticType::List { element } | SemanticType::Set { element } => { + vec![element.as_ref().clone()] + } + SemanticType::Map { key, value } => vec![SemanticType::Product { + left: key.clone(), + right: value.clone(), + }], + SemanticType::Option { value } => vec![value.as_ref().clone()], + SemanticType::Product { left, right } => { + vec![left.as_ref().clone(), right.as_ref().clone()] + } + SemanticType::ContractViolation | SemanticType::ReasoningFailure => { + vec![SemanticType::Bool, SemanticType::Bool] + } + SemanticType::Result { ok, error } => vec![error.as_ref().clone(), ok.as_ref().clone()], + SemanticType::Named { + member: _, + arguments: _, + } + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } + | SemanticType::Nat + | SemanticType::Bool + | SemanticType::Unit + | SemanticType::Int + | SemanticType::Int8 + | SemanticType::Int16 + | SemanticType::Int32 + | SemanticType::Int64 + | SemanticType::UInt8 + | SemanticType::UInt16 + | SemanticType::UInt32 + | SemanticType::UInt64 + | SemanticType::String + | SemanticType::Bytes + | SemanticType::Ordering + | SemanticType::Function { + parameters: _, + result: _, + } => return Err("the constructors of a non-container".to_owned()), + }) +} + +/// The type arguments a document type is instantiated at. +fn type_arguments(ty: &SemanticType) -> Vec { + match ty { + SemanticType::Named { + member: _, + arguments, + } => arguments.clone(), + SemanticType::List { element: _ } + | SemanticType::Set { element: _ } + | SemanticType::Map { key: _, value: _ } + | SemanticType::Option { value: _ } + | SemanticType::Product { left: _, right: _ } + | SemanticType::Result { ok: _, error: _ } + | SemanticType::ContractViolation + | SemanticType::ReasoningFailure + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } + | SemanticType::Nat + | SemanticType::Bool + | SemanticType::Unit + | SemanticType::Int + | SemanticType::Int8 + | SemanticType::Int16 + | SemanticType::Int32 + | SemanticType::Int64 + | SemanticType::UInt8 + | SemanticType::UInt16 + | SemanticType::UInt32 + | SemanticType::UInt64 + | SemanticType::String + | SemanticType::Bytes + | SemanticType::Ordering + | SemanticType::Function { + parameters: _, + result: _, + } => Vec::new(), + } +} + +/// The member a document type names. +fn named_member(ty: &SemanticType) -> Result { + match ty { + SemanticType::Named { + member, + arguments: _, + } => Ok(member.clone()), + SemanticType::List { element: _ } + | SemanticType::Set { element: _ } + | SemanticType::Map { key: _, value: _ } + | SemanticType::Option { value: _ } + | SemanticType::Product { left: _, right: _ } + | SemanticType::Result { ok: _, error: _ } + | SemanticType::ContractViolation + | SemanticType::ReasoningFailure + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } + | SemanticType::Nat + | SemanticType::Bool + | SemanticType::Unit + | SemanticType::Int + | SemanticType::Int8 + | SemanticType::Int16 + | SemanticType::Int32 + | SemanticType::Int64 + | SemanticType::UInt8 + | SemanticType::UInt16 + | SemanticType::UInt32 + | SemanticType::UInt64 + | SemanticType::String + | SemanticType::Bytes + | SemanticType::Ordering + | SemanticType::Function { + parameters: _, + result: _, + } => Err("a document type that is not named".to_owned()), + } +} + +/// The binder a parameter is named by in the certificate, as the text +/// generator names it. +fn binder_name(name: &str) -> String { + match name.strip_prefix("__") { + Some(rest) if !name.contains('.') => format!("_y{rest}"), + _ => name.to_owned(), + } +} + +/// The element type of a container nested in a recursive group. +fn element_type(container: &SemanticType, element: &SemanticType) -> SemanticType { + match container { + SemanticType::Map { key, value: _ } => SemanticType::Product { + left: key.clone(), + right: Box::new(element.clone()), + }, + SemanticType::List { element: _ } + | SemanticType::Set { element: _ } + | SemanticType::ContractViolation + | SemanticType::ReasoningFailure + | SemanticType::Option { value: _ } + | SemanticType::Result { ok: _, error: _ } + | SemanticType::Product { left: _, right: _ } + | SemanticType::Named { + member: _, + arguments: _, + } + | SemanticType::Function { + parameters: _, + result: _, + } + | SemanticType::Type + | SemanticType::Prop + | SemanticType::Parameter { name: _ } + | SemanticType::Nat + | SemanticType::Bool + | SemanticType::Unit + | SemanticType::Int + | SemanticType::Int8 + | SemanticType::Int16 + | SemanticType::Int32 + | SemanticType::Int64 + | SemanticType::UInt8 + | SemanticType::UInt16 + | SemanticType::UInt32 + | SemanticType::UInt64 + | SemanticType::String + | SemanticType::Bytes + | SemanticType::Ordering => element.clone(), + } +} + +/// A theorem row of the module, its axioms pinned exactly. +fn theorem_row(name: String, ty: Term, value: Term, axioms: &BTreeSet) -> CoreDeclaration { + CoreDeclaration { + all: Some(vec![name.clone()]), + name, + levels: Vec::new(), + kind: CoreDeclKind::Theorem, + reducibility: None, + transparency: CoreTransparency::Semireducible, + policy: CoreAxiomPolicy::Exact(axioms.iter().cloned().collect()), + r#type: ty, + value: Some(value), + inductive: None, + class: false, + instance: None, + generated: false, + safety: None, + compiled: false, + tags: Vec::new(), + no_confusion: None, + matcher: None, + projection: None, + simp: None, + eqn_info: None, + inline: None, + sparse: None, + grind: None, + } +} + +impl Gen<'_> { + /// Certificate E of the root as a native core module (SPEC.md §17.17). + pub(super) fn compose_data( + &self, + root_module: &str, + root_name: &str, + module_a: &str, + module_b: &str, + name: &str, + fallible: bool, + ) -> Result { + Composer::new(self, module_a, module_b, name).module(root_module, root_name, fallible) + } +} diff --git a/crates/lexlean/src/production/kernel.rs b/crates/lexlean/src/production/kernel.rs new file mode 100644 index 000000000..000893dd7 --- /dev/null +++ b/crates/lexlean/src/production/kernel.rs @@ -0,0 +1,600 @@ +//! Kernel terms built as data (SPEC.md §17.10, §17.17). +//! +//! A certificate held as kernel-term data is a native core module: a shared +//! expression DAG and declaration rows the one core backend renders to the +//! Lean that verification compiles. This module is the builder of that DAG. +//! Every argument and universe level is written, as a kernel term has them: a +//! lemma of the preservation library is applied by reading its recorded +//! Π-type out of the native library data and instantiating one binder after +//! another with the argument given for it, so that the type of each further +//! binder, and of the application, is a substitution and never an inference. +//! Where the elaborator would have unified an `rfl`, the argument is written +//! as `Eq.refl` at the type the instantiated binder states. +//! +//! The builder shares equal nodes (the DAG of the schema is child before +//! parent), keeps the lemma names each term applies so a row can pin its +//! axioms from the library registry, and hands the finished nodes to a +//! [`CoreModule`]. + +use std::collections::{BTreeSet, HashMap}; + +use crate::ir::core::{CoreBinderInfo, CoreLevel, CoreModule, CoreNode}; + +/// A node of the DAG under construction. +pub type Term = usize; + +/// One argument of a lemma application: a term, or the reflexivity proof of +/// the equation the binder states. +#[derive(Debug, Clone, Copy)] +pub enum Arg { + /// The term. + Term(Term), + /// `Eq.refl` at the type the instantiated binder states, which must be + /// an equation. + Refl, +} + +/// A lemma applied: the term and its type after every argument. +#[derive(Debug, Clone, Copy)] +pub struct Applied { + pub term: Term, + pub ty: Term, +} + +/// The builder of a core module's expression DAG. +#[derive(Debug, Default)] +pub struct Builder { + nodes: Vec, + shared: HashMap, + /// The library lemmas the terms built so far apply, by name. + lemmas: BTreeSet, +} + +/// The empty binder name, which the notation writes as `_`. +const ANONYMOUS: &str = ""; + +impl Builder { + #[must_use] + pub fn new() -> Self { + Self::default() + } + + /// The nodes built so far. + #[must_use] + pub fn nodes(&self) -> &[CoreNode] { + &self.nodes + } + + /// The lemma names applied since the last [`Self::take_lemmas`]. + pub fn take_lemmas(&mut self) -> BTreeSet { + std::mem::take(&mut self.lemmas) + } + + /// Record a lemma name among the applied ones. + pub fn note_lemma(&mut self, name: &str) { + self.lemmas.insert(name.to_owned()); + } + + fn push(&mut self, node: CoreNode) -> Term { + if let Some(&index) = self.shared.get(&node) { + return index; + } + let index = self.nodes.len(); + self.nodes.push(node.clone()); + self.shared.insert(node, index); + index + } + + /// The node at `term`. + #[must_use] + pub fn node(&self, term: Term) -> &CoreNode { + &self.nodes[term] + } + + // --- Atoms ------------------------------------------------------------ + + pub fn bvar(&mut self, i: usize) -> Term { + self.push(CoreNode::BVar { i }) + } + + pub fn sort(&mut self, level: CoreLevel) -> Term { + self.push(CoreNode::Sort { l: level }) + } + + /// `Prop`. + pub fn prop(&mut self) -> Term { + self.sort(CoreLevel::Zero) + } + + /// `Type`. + pub fn type0(&mut self) -> Term { + self.sort(CoreLevel::Succ(Box::new(CoreLevel::Zero))) + } + + /// A constant with no universe levels. + pub fn konst(&mut self, name: &str) -> Term { + self.push(CoreNode::Const { + n: name.to_owned(), + u: Vec::new(), + }) + } + + /// A constant at the given universe levels. + pub fn konst_at(&mut self, name: &str, levels: Vec) -> Term { + self.push(CoreNode::Const { + n: name.to_owned(), + u: levels, + }) + } + + /// A constant at universe level 0 (`List.{0}`, `Option.{0}`). + pub fn konst0(&mut self, name: &str) -> Term { + self.konst_at(name, vec![CoreLevel::Zero]) + } + + /// A constant at universe level 1 (`Eq.{1}` over a type in `Type`). + pub fn konst1(&mut self, name: &str) -> Term { + self.konst_at(name, vec![CoreLevel::Succ(Box::new(CoreLevel::Zero))]) + } + + /// A constant at universe levels 0, 0 (`Prod.{0, 0}`, `Except.{0, 0}`). + pub fn konst00(&mut self, name: &str) -> Term { + self.konst_at(name, vec![CoreLevel::Zero, CoreLevel::Zero]) + } + + /// A natural-number literal. + pub fn nat(&mut self, value: u64) -> Term { + self.push(CoreNode::Nat { + v: value.to_string(), + }) + } + + /// A string literal. + pub fn string(&mut self, value: &str) -> Term { + self.push(CoreNode::String { + v: value.chars().map(u32::from).collect(), + }) + } + + // --- Compound nodes --------------------------------------------------- + + pub fn app(&mut self, f: Term, x: Term) -> Term { + self.push(CoreNode::App { f, x }) + } + + /// `f x₁ … xₙ`. + pub fn apps(&mut self, f: Term, args: &[Term]) -> Term { + args.iter().fold(f, |f, &x| self.app(f, x)) + } + + /// `fun (name : ty) => body`, `body` written over `#0` for `name`. + pub fn lam(&mut self, name: &str, binder: CoreBinderInfo, ty: Term, body: Term) -> Term { + self.push(CoreNode::Lambda { + n: name.to_owned(), + b: binder, + t: ty, + v: body, + }) + } + + /// `(name : ty) -> body`, `body` written over `#0` for `name`. + pub fn pi(&mut self, name: &str, binder: CoreBinderInfo, ty: Term, body: Term) -> Term { + self.push(CoreNode::Forall { + n: name.to_owned(), + b: binder, + t: ty, + v: body, + }) + } + + /// `a -> b` with the anonymous explicit binder; `b` must not mention `#0`, + /// which the caller ensures by lifting it. + pub fn arrow(&mut self, a: Term, b: Term) -> Term { + let lifted = self.lift(b, 1, 0); + self.pi(ANONYMOUS, CoreBinderInfo::Explicit, a, lifted) + } + + // --- Lists and standard constructions --------------------------------- + + /// `[x₁, …, xₙ] : List α` at universe level 0. + pub fn list(&mut self, element: Term, items: &[Term]) -> Term { + let nil = self.konst0("List.nil"); + let cons = self.konst0("List.cons"); + let mut out = self.app(nil, element); + for &item in items.iter().rev() { + out = self.apps(cons, &[element, item, out]); + } + out + } + + /// `List α` at universe level 0. + pub fn list_ty(&mut self, element: Term) -> Term { + let list = self.konst0("List"); + self.app(list, element) + } + + /// `(a, b) : Prod α β` at universe levels 0, 0. + pub fn pair(&mut self, alpha: Term, beta: Term, a: Term, b: Term) -> Term { + let mk = self.konst00("Prod.mk"); + self.apps(mk, &[alpha, beta, a, b]) + } + + /// `Prod α β` at universe levels 0, 0. + pub fn pair_ty(&mut self, alpha: Term, beta: Term) -> Term { + let prod = self.konst00("Prod"); + self.apps(prod, &[alpha, beta]) + } + + // --- Substitution ----------------------------------------------------- + + /// `term` with every loose variable at or above `cutoff` raised by `n`. + pub fn lift(&mut self, term: Term, n: usize, cutoff: usize) -> Term { + if n == 0 { + return term; + } + let mut memo = HashMap::new(); + self.lift_memo(term, n, cutoff, &mut memo) + } + + fn lift_memo( + &mut self, + term: Term, + n: usize, + cutoff: usize, + memo: &mut HashMap<(Term, usize), Term>, + ) -> Term { + if let Some(&done) = memo.get(&(term, cutoff)) { + return done; + } + let out = match self.nodes[term].clone() { + CoreNode::BVar { i } => { + if i >= cutoff { + self.bvar(i + n) + } else { + term + } + } + CoreNode::Sort { .. } + | CoreNode::Const { .. } + | CoreNode::Nat { .. } + | CoreNode::String { .. } => term, + CoreNode::App { f, x } => { + let f = self.lift_memo(f, n, cutoff, memo); + let x = self.lift_memo(x, n, cutoff, memo); + self.app(f, x) + } + CoreNode::Lambda { n: name, b, t, v } => { + let t = self.lift_memo(t, n, cutoff, memo); + let v = self.lift_memo(v, n, cutoff + 1, memo); + self.lam(&name, b, t, v) + } + CoreNode::Forall { n: name, b, t, v } => { + let t = self.lift_memo(t, n, cutoff, memo); + let v = self.lift_memo(v, n, cutoff + 1, memo); + self.pi(&name, b, t, v) + } + CoreNode::Let { + n: name, + t, + v, + body, + d, + } => { + let t = self.lift_memo(t, n, cutoff, memo); + let v = self.lift_memo(v, n, cutoff, memo); + let body = self.lift_memo(body, n, cutoff + 1, memo); + self.push(CoreNode::Let { + n: name, + t, + v, + body, + d, + }) + } + CoreNode::Mdata { m, x } => { + let x = self.lift_memo(x, n, cutoff, memo); + self.push(CoreNode::Mdata { m, x }) + } + CoreNode::Projection { n: name, s, i, x } => { + let x = self.lift_memo(x, n, cutoff, memo); + self.push(CoreNode::Projection { n: name, s, i, x }) + } + }; + memo.insert((term, cutoff), out); + out + } + + /// `body` with `#0` replaced by `arg` and every other loose variable + /// lowered by one: the body of a binder instantiated at `arg`. + pub fn instantiate(&mut self, body: Term, arg: Term) -> Term { + let mut memo = HashMap::new(); + self.instantiate_memo(body, arg, 0, &mut memo) + } + + fn instantiate_memo( + &mut self, + term: Term, + arg: Term, + depth: usize, + memo: &mut HashMap<(Term, usize), Term>, + ) -> Term { + if let Some(&done) = memo.get(&(term, depth)) { + return done; + } + let out = match self.nodes[term].clone() { + CoreNode::BVar { i } => { + if i == depth { + self.lift(arg, depth, 0) + } else if i > depth { + self.bvar(i - 1) + } else { + term + } + } + CoreNode::Sort { .. } + | CoreNode::Const { .. } + | CoreNode::Nat { .. } + | CoreNode::String { .. } => term, + CoreNode::App { f, x } => { + let f = self.instantiate_memo(f, arg, depth, memo); + let x = self.instantiate_memo(x, arg, depth, memo); + self.app(f, x) + } + CoreNode::Lambda { n, b, t, v } => { + let t = self.instantiate_memo(t, arg, depth, memo); + let v = self.instantiate_memo(v, arg, depth + 1, memo); + self.lam(&n, b, t, v) + } + CoreNode::Forall { n, b, t, v } => { + let t = self.instantiate_memo(t, arg, depth, memo); + let v = self.instantiate_memo(v, arg, depth + 1, memo); + self.pi(&n, b, t, v) + } + CoreNode::Let { n, t, v, body, d } => { + let t = self.instantiate_memo(t, arg, depth, memo); + let v = self.instantiate_memo(v, arg, depth, memo); + let body = self.instantiate_memo(body, arg, depth + 1, memo); + self.push(CoreNode::Let { n, t, v, body, d }) + } + CoreNode::Mdata { m, x } => { + let x = self.instantiate_memo(x, arg, depth, memo); + self.push(CoreNode::Mdata { m, x }) + } + CoreNode::Projection { n, s, i, x } => { + let x = self.instantiate_memo(x, arg, depth, memo); + self.push(CoreNode::Projection { n, s, i, x }) + } + }; + memo.insert((term, depth), out); + out + } + + /// Whether `term` mentions a loose variable at or above `cutoff`. + #[must_use] + pub fn has_loose(&self, term: Term, cutoff: usize) -> bool { + match &self.nodes[term] { + CoreNode::BVar { i } => *i >= cutoff, + CoreNode::Sort { .. } + | CoreNode::Const { .. } + | CoreNode::Nat { .. } + | CoreNode::String { .. } => false, + CoreNode::App { f, x } => self.has_loose(*f, cutoff) || self.has_loose(*x, cutoff), + CoreNode::Lambda { t, v, .. } | CoreNode::Forall { t, v, .. } => { + self.has_loose(*t, cutoff) || self.has_loose(*v, cutoff + 1) + } + CoreNode::Let { t, v, body, .. } => { + self.has_loose(*t, cutoff) + || self.has_loose(*v, cutoff) + || self.has_loose(*body, cutoff + 1) + } + CoreNode::Mdata { x, .. } | CoreNode::Projection { x, .. } => { + self.has_loose(*x, cutoff) + } + } + } + + // --- Importing from another module ------------------------------------ + + /// The node `root` of `source`, copied into this DAG with its children. + pub fn import(&mut self, source: &CoreModule, root: usize) -> Term { + let mut memo = HashMap::new(); + self.import_memo(source, root, &mut memo) + } + + fn import_memo( + &mut self, + source: &CoreModule, + index: usize, + memo: &mut HashMap, + ) -> Term { + if let Some(&done) = memo.get(&index) { + return done; + } + let out = match &source.nodes[index] { + node @ (CoreNode::BVar { .. } + | CoreNode::Sort { .. } + | CoreNode::Const { .. } + | CoreNode::Nat { .. } + | CoreNode::String { .. }) => self.push(node.clone()), + CoreNode::App { f, x } => { + let f = self.import_memo(source, *f, memo); + let x = self.import_memo(source, *x, memo); + self.app(f, x) + } + CoreNode::Lambda { n, b, t, v } => { + let t = self.import_memo(source, *t, memo); + let v = self.import_memo(source, *v, memo); + self.lam(n, *b, t, v) + } + CoreNode::Forall { n, b, t, v } => { + let t = self.import_memo(source, *t, memo); + let v = self.import_memo(source, *v, memo); + self.pi(n, *b, t, v) + } + CoreNode::Let { n, t, v, body, d } => { + let t = self.import_memo(source, *t, memo); + let v = self.import_memo(source, *v, memo); + let body = self.import_memo(source, *body, memo); + self.push(CoreNode::Let { + n: n.clone(), + t, + v, + body, + d: *d, + }) + } + // An annotation is kernel-irrelevant; a statement states the term. + CoreNode::Mdata { m: _, x } => self.import_memo(source, *x, memo), + CoreNode::Projection { n, s, i, x } => { + let x = self.import_memo(source, *x, memo); + self.push(CoreNode::Projection { + n: n.clone(), + s: s.clone(), + i: *i, + x, + }) + } + }; + memo.insert(index, out); + out + } + + // --- Application against a Π-type ------------------------------------- + + /// The head and arguments of an application spine. + #[must_use] + pub fn spine(&self, term: Term) -> (Term, Vec) { + let mut args = Vec::new(); + let mut head = term; + while let CoreNode::App { f, x } = &self.nodes[head] { + args.push(*x); + head = *f; + } + args.reverse(); + (head, args) + } + + /// `head`, whose type is `ty`, applied to `args` binder by binder: each + /// explicit term instantiates the binder it fills, and a [`Arg::Refl`] + /// is `Eq.refl` at the equation the binder states. The result's type is + /// the body after the last argument. + /// + /// # Errors + /// + /// More arguments than binders, or a reflexivity argument at a binder + /// whose type is not an equation. + pub fn apply_pi(&mut self, head: Term, ty: Term, args: &[Arg]) -> Result { + let mut term = head; + let mut ty = ty; + for (position, arg) in args.iter().enumerate() { + let (domain, body) = match &self.nodes[ty] { + CoreNode::Forall { t, v, .. } => (*t, *v), + _ => { + return Err(format!( + "argument {position} applied to a term whose type is not a binder" + )); + } + }; + let value = match arg { + Arg::Term(value) => *value, + Arg::Refl => { + let (head, parts) = self.spine(domain); + let levels = match &self.nodes[head] { + CoreNode::Const { n, u } if n == "Eq" && parts.len() == 3 => u.clone(), + _ => { + return Err(format!( + "argument {position}: a reflexivity proof at a binder that is not an equation" + )); + } + }; + let refl = self.konst_at("Eq.refl", levels); + self.apps(refl, &[parts[0], parts[1]]) + } + }; + term = self.app(term, value); + ty = self.instantiate(body, value); + } + Ok(Applied { term, ty }) + } + + /// The binders of a Π-type, outermost first, with the body after them: + /// each binder's type is written over the earlier binders. + #[must_use] + pub fn binders(&self, ty: Term) -> (Vec<(String, CoreBinderInfo, Term)>, Term) { + let mut out = Vec::new(); + let mut body = ty; + while let CoreNode::Forall { n, b, t, v } = &self.nodes[body] { + out.push((n.clone(), *b, *t)); + body = *v; + } + (out, body) + } + + /// The finished DAG. + #[must_use] + pub fn finish(self) -> Vec { + self.nodes + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn instantiating_a_binder_substitutes_and_lowers() { + let mut b = Builder::new(); + let nat = b.konst("Nat"); + // (x : Nat) -> (y : Nat) -> Eq Nat x y, written over #1 and #0. + let x = b.bvar(1); + let y = b.bvar(0); + let eq = b.konst1("Eq"); + let body = b.apps(eq, &[nat, x, y]); + let inner = b.pi("y", CoreBinderInfo::Explicit, nat, body); + let ty = b.pi("x", CoreBinderInfo::Explicit, nat, inner); + let zero = b.nat(0); + let f = b.konst("f"); + let applied = b.apply_pi(f, ty, &[Arg::Term(zero)]).expect("one argument"); + let (binders, result) = b.binders(applied.ty); + assert_eq!(binders.len(), 1); + let (head, parts) = b.spine(result); + assert!(matches!(b.node(head), CoreNode::Const { n, .. } if n == "Eq")); + assert_eq!(parts[1], zero, "x became the literal"); + assert!( + matches!(b.node(parts[2]), CoreNode::BVar { i: 0 }), + "y is still #0" + ); + assert_eq!(applied.term, b.app(f, zero)); + } + + #[test] + fn a_reflexivity_argument_is_eq_refl_at_the_stated_equation() { + let mut b = Builder::new(); + let nat = b.konst("Nat"); + let one = b.nat(1); + let eq = b.konst1("Eq"); + let equation = b.apps(eq, &[nat, one, one]); + let prop = b.prop(); + let lifted = b.lift(prop, 1, 0); + let ty = b.pi("h", CoreBinderInfo::Explicit, equation, lifted); + let f = b.konst("f"); + let applied = b.apply_pi(f, ty, &[Arg::Refl]).expect("one argument"); + let (_, args) = b.spine(applied.term); + let (refl_head, refl_args) = b.spine(args[0]); + assert!(matches!(b.node(refl_head), CoreNode::Const { n, .. } if n == "Eq.refl")); + assert_eq!(refl_args, vec![nat, one]); + assert_eq!(applied.ty, prop); + } + + #[test] + fn equal_nodes_are_shared() { + let mut b = Builder::new(); + let a = b.konst("Nat"); + let c = b.konst("Nat"); + assert_eq!(a, c); + let list1 = b.list(a, &[]); + let list2 = b.list(c, &[]); + assert_eq!(list1, list2); + assert!(b.nodes().len() < 6); + } +} diff --git a/crates/lexlean/src/production/mod.rs b/crates/lexlean/src/production/mod.rs index fe8d43227..c9bf3c96f 100644 --- a/crates/lexlean/src/production/mod.rs +++ b/crates/lexlean/src/production/mod.rs @@ -9,6 +9,7 @@ pub mod certificate; pub mod eligibility; +pub mod kernel; pub mod lcnf; pub mod lean_list; pub mod lower; diff --git a/crates/lexlean/src/production/preserve.rs b/crates/lexlean/src/production/preserve.rs index a2cc3fc66..65bbff4bd 100644 --- a/crates/lexlean/src/production/preserve.rs +++ b/crates/lexlean/src/production/preserve.rs @@ -128,6 +128,10 @@ pub struct StagedFile { pub path: String, pub module: String, pub text: String, + /// The record of a certificate held as kernel data: its authoring + /// notation, which the verify record holds in place of the Lean the + /// decoder compiles. + pub source: Option, } /// The files a project's certificates compile in, and their order. @@ -167,6 +171,11 @@ struct Native { texts: BTreeMap, /// The declarations a Lean command can name, with their exact axioms. declarations: Vec, + /// The native modules themselves, by name: the kernel data a certificate + /// built as data reads its lemma types from. + modules: BTreeMap, + /// Every declaration row by name: its module and its position. + rows: BTreeMap, } /// The embedded module list, checked for its tag and toolchain. @@ -298,6 +307,8 @@ fn build_native( ) -> Result { let mut texts = BTreeMap::new(); let mut declarations = Vec::new(); + let mut modules = BTreeMap::new(); + let mut rows = BTreeMap::new(); let mut seen_modules: BTreeSet = BTreeSet::new(); let mut names = BTreeSet::new(); // The source that first declared each equation lemma, by name. @@ -375,11 +386,17 @@ fn build_native( let text = crate::backend::core::lean_text(&core) .map_err(|diagnostic| format!("{path}: {}", diagnostic.message))?; texts.insert(module.clone(), text); + for (position, row) in core.declarations.iter().enumerate() { + rows.insert(row.name.clone(), (module.clone(), position)); + } + modules.insert(module.clone(), core); seen_modules.insert(module.clone()); } Ok(Native { texts, declarations, + modules, + rows, }) } @@ -422,6 +439,121 @@ fn native() -> Result<&'static Native, Diagnostic> { NATIVE.get_or_init(load_native).as_ref().map_err(internal) } +/// A declaration of the native library by name, with the module that holds +/// it: the kernel data a certificate built as data reads a lemma's type +/// from (SPEC.md §17.17). +/// +/// # Errors +/// +/// A name no native module declares, or a library that does not load. +pub(crate) fn native_declaration( + name: &str, +) -> Result< + ( + &'static crate::ir::core::CoreModule, + &'static crate::ir::core::CoreDeclaration, + ), + String, +> { + let native = native().map_err(|diagnostic| diagnostic.message.clone())?; + let (module, position) = native + .rows + .get(name) + .ok_or_else(|| format!("the preservation library declares no `{name}`"))?; + let core = native + .modules + .get(module) + .ok_or_else(|| format!("the library has no module `{module}`"))?; + Ok((core, &core.declarations[*position])) +} + +/// The exact axioms the registry records for a library declaration. +/// +/// # Errors +/// +/// A name no native module declares. +pub(crate) fn library_axioms(name: &str) -> Result, String> { + let (_, declaration) = native_declaration(name)?; + Ok(declaration.policy.axioms().to_vec()) +} + +/// Audit a certificate held as kernel data, row by row and node by node +/// (SP-14): it imports only modules of the environment, declares only +/// theorems, definitions, and abbreviations, every one of them safe, with its +/// axioms pinned exactly, and names no forbidden constant in any spelling. A +/// certificate as data has no text to scan: the schema admits no axiom and +/// no tactic, and the kernel checks every term. +/// +/// # Errors +/// +/// The first rule the module breaks. +pub fn audit_core( + module: &crate::ir::core::CoreModule, + environment: &BTreeSet, +) -> Result<(), String> { + use crate::ir::core::{CoreAxiomPolicy, CoreDeclKind, CoreNode}; + for import in &module.imports { + if !environment.contains(import) { + return Err(format!("the import `{import}` is outside the environment")); + } + } + for row in &module.declarations { + if row.generated { + return Err(format!("the row `{}` is marked generated", row.name)); + } + if !matches!( + row.kind, + CoreDeclKind::Theorem | CoreDeclKind::Definition | CoreDeclKind::Abbrev + ) { + return Err(format!( + "the row `{}` declares a {:?}, which a certificate does not", + row.name, row.kind + )); + } + if row.safety.is_some() { + return Err(format!("the row `{}` is not a safe definition", row.name)); + } + if !matches!(row.policy, CoreAxiomPolicy::Exact(_)) { + return Err(format!( + "the row `{}` does not pin its axioms exactly", + row.name + )); + } + } + for node in &module.nodes { + if let CoreNode::Const { n, .. } = node { + if n.split('.') + .any(|segment| FORBIDDEN_CONSTANTS.contains(&segment)) + { + return Err(format!("the forbidden constant `{n}`")); + } + } + } + Ok(()) +} + +/// Audit a certificate: as data when it is held as data, else token by token +/// as text. +fn audit_certificate( + certificate: &Certificate, + environment: &BTreeSet, +) -> Result<(), String> { + match &certificate.data { + Some(data) => audit_core(data, environment), + None => audit_tokens(&certificate.text, environment), + } +} + +/// The bytes a verify record holds for a certificate: the notation of one +/// held as data, else its Lean text. +#[must_use] +pub fn recorded_bytes(certificate: &Certificate) -> &[u8] { + match &certificate.source { + Some(source) => source.as_bytes(), + None => certificate.text.as_bytes(), + } +} + /// The library registry: the module list the project ships and every /// declaration of the native modules a Lean command can name, with its exact /// axioms. @@ -452,6 +584,17 @@ pub fn module_text(module: &str) -> Result<&'static str, Diagnostic> { .ok_or_else(|| internal(format!("the library has no module `{module}`"))) } +/// The path of a certificate held as kernel data in a verify record: the +/// module's path with the authoring notation's extension (SPEC.md §17.21.8). +#[must_use] +pub fn notation_path(module: &str) -> String { + let path = module_path(module); + match path.strip_suffix(".lean") { + Some(stem) => format!("{stem}.lex.tex"), + None => format!("{path}.lex.tex"), + } +} + /// The modules a Lean source imports. fn imports(text: &str) -> Vec { text.lines() @@ -521,6 +664,17 @@ fn audit_text(library: &Library, certificates: &[Certificate]) -> String { for certificate in certificates { text.push_str(&format!("#print axioms {}\n", certificate.theorem)); } + // A certificate held as data pins the axioms of every row: the audit + // prints them all, so a row whose policy lies is refused. + for certificate in certificates { + if let Some(data) = &certificate.data { + for row in &data.declarations { + if row.name != certificate.theorem { + text.push_str(&format!("#print axioms {}\n", row.name)); + } + } + } + } text.push_str(&format!("#print \"{VOCABULARY_MARKER}\"\n")); for (name, statement) in VOCABULARY { match statement { @@ -1101,6 +1255,7 @@ fn runtime_files<'a>( path: module_path(&runtime.name), text: runtime.text.clone(), module: runtime.name.clone(), + source: None, }) .collect()) } @@ -1131,6 +1286,7 @@ pub fn workspace( path: module_path(&runtime.name), text: runtime.text.clone(), module: runtime.name.clone(), + source: None, }); } for module in TARGET_MODULES @@ -1146,6 +1302,7 @@ pub fn workspace( path: module_path(&module), text: text.to_owned(), module, + source: None, }); } for (module, text) in ordered(user)? { @@ -1161,11 +1318,12 @@ pub fn workspace( path: module_path(&module), module, text, + source: None, }); } environment.extend(user.iter().map(|(module, _)| module.clone())); for certificate in certificates { - audit_tokens(&certificate.text, &environment).map_err(|reason| { + audit_certificate(certificate, &environment).map_err(|reason| { internal(format!( "the certificate `{}`: {reason}", certificate.module @@ -1182,6 +1340,7 @@ pub fn workspace( path: module_path(&certificate.module), module: certificate.module.clone(), text: certificate.text.clone(), + source: certificate.source.clone(), }); } Ok(Workspace { @@ -1194,6 +1353,7 @@ pub fn workspace( path: module_path(AUDIT_MODULE), module: AUDIT_MODULE.to_owned(), text: audit_text(&library, certificates), + source: None, }, }) } @@ -1284,6 +1444,27 @@ pub fn audit(output: &str, certificates: &[Certificate]) -> Result<(), String> { )); } } + if let Some(data) = &certificate.data { + for row in &data.declarations { + let mut pinned = row.policy.axioms().to_vec(); + pinned.sort(); + match printed.get(&row.name) { + Some(axioms) if *axioms == pinned => {} + Some(axioms) => { + return Err(format!( + "the certificate row `{}` depends on {axioms:?}, its policy pins {pinned:?}", + row.name + )); + } + None => { + return Err(format!( + "the audit printed no axioms for the certificate row `{}`", + row.name + )); + } + } + } + } } Ok(()) } @@ -1340,12 +1521,13 @@ pub fn stage(modules: &[String], certificates: &[Certificate]) -> Result Result Result crate::artifact::canonical_json::Json ), ( "byte_length", - Json::from_usize(composed.text.len()), + Json::from_usize( + recorded_bytes(composed).len(), + ), ), ( "sha256", Json::Str( - Sha256Digest::of( - composed.text.as_bytes(), - ) + Sha256Digest::of(recorded_bytes( + composed, + )) .to_hex(), ), ), @@ -1644,6 +1830,15 @@ pub fn record(roots: &[CertifiedRoot]) -> crate::artifact::canonical_json::Json /// rejection concerns. #[must_use] pub fn failing_declaration(text: &str, output: &str) -> Option { + // A certificate held as data is added by the decoder, whose message + // names the declaration the kernel refused. + if let Some(named) = output.lines().find_map(|line| { + let (_, rest) = line.split_once("native core declaration '")?; + let (name, _) = rest.split_once('\'')?; + name.rsplit('.').next().map(str::to_owned) + }) { + return Some(named); + } let line: usize = output.lines().find_map(|line| { let (_, rest) = line.split_once(".lean:")?; let (number, rest) = rest.split_once(':')?; diff --git a/crates/lexlean/src/production/rust_cert.rs b/crates/lexlean/src/production/rust_cert.rs index 7de078668..deba14d84 100644 --- a/crates/lexlean/src/production/rust_cert.rs +++ b/crates/lexlean/src/production/rust_cert.rs @@ -103,6 +103,8 @@ impl CertificateB { theorem: self.theorem, text: self.text, imports: Vec::new(), + data: None, + source: None, } } } diff --git a/crates/lexlean/src/production/source.rs b/crates/lexlean/src/production/source.rs index c5e90eee4..184884504 100644 --- a/crates/lexlean/src/production/source.rs +++ b/crates/lexlean/src/production/source.rs @@ -119,6 +119,19 @@ impl<'a> Source<'a> { }) } + /// The position of the declaration `name` among `module`'s elaborated + /// declarations: the order Lean declares them in, which a mutual block's + /// recursors follow. + pub(crate) fn declaration_position(&self, module: &str, name: &str) -> Option { + self.modules.get(module).and_then(|linked| { + linked + .semantic + .lowered_declarations() + .into_iter() + .position(|declaration| declaration.name() == name) + }) + } + /// The generated Lean module of a source module. pub(crate) fn lean_module(&self, module: &str) -> Result<&'a str, String> { self.modules diff --git a/crates/lexlean/src/verify/mod.rs b/crates/lexlean/src/verify/mod.rs index b85c11777..984a0f8bd 100644 --- a/crates/lexlean/src/verify/mod.rs +++ b/crates/lexlean/src/verify/mod.rs @@ -2487,11 +2487,20 @@ pub fn run_part( )?; tail_records.push(audit_record); for file in &stage.certificates { - write_staged( - staging.path(), - &format!("preserve/{}", file.path), - file.text.as_bytes(), - )?; + // A certificate held as data is recorded in the authoring + // notation; the Lean the decoder compiles is rendered from it. + match &file.source { + Some(source) => write_staged( + staging.path(), + &format!("preserve/{}", preserve::notation_path(&file.module)), + source.as_bytes(), + )?, + None => write_staged( + staging.path(), + &format!("preserve/{}", file.path), + file.text.as_bytes(), + )?, + } } // The program each root's certificates are about and the crate each // target's certificates B and E are about, published beside them and diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R0/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R0/Compose/RustStd.lean deleted file mode 100644 index 708d022eb..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R0/Compose/RustStd.lean +++ /dev/null @@ -1,28 +0,0 @@ -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0 -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Models.Glyphs.Glyph)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.program _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.krate _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.flags (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.__enc_0 __v) (.adt 0) - | Models.Glyphs.Glyph.g0 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g1 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g2 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g3 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g4 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g5 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g6 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g7 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g8 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g9 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (glyph : (Models.Glyphs.Glyph)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.__enc_0 glyph)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.denote glyph) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.__enc_0 glyph)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 glyph) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.root glyph) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R0/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R0/Compose/RustStd.lex.tex new file mode 100644 index 000000000..a7b298e4e --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R0/Compose/RustStd.lex.tex @@ -0,0 +1,585 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0, + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.__wt_0 : @16 := @448 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.root : @1168 := @1169 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.program +@1 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.krate +@2 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.flags +@3 := Models.Glyphs.Glyph +@4 := #0 +@5 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := (__v : @3) -> @15 +@17 := fun (__v : @3) => @15 +@18 := LexLeanTarget.TargetSyntax.Value +@19 := LexLeanTarget.TargetSyntax.Ty +@20 := List.nil.{0} +@21 := List.cons.{0} +@22 := @20 @18 +@23 := @20 @19 +@24 := LexLeanTarget.TargetSyntax.Program +@25 := LexLeanPreservation.Rust.RCrate +@26 := LexLeanPreservation.Rust.Flags +@27 := LexLeanPreservation.Rust.WTL +@28 := #2 +@29 := @27 @28 +@30 := #1 +@37 := {p : @24} -> {c : @25} -> {A : @26} -> @29 @30 @4 @22 @23 +@39 := LexLeanPreservation.Rust.wtl_nil @0 +@40 := @27 @0 +@46 := {c : @25} -> {A : @26} -> @40 @30 @4 @22 @23 +@47 := @39 @1 +@48 := @40 @1 +@52 := {A : @26} -> @48 @4 @22 @23 +@53 := @47 @2 +@54 := @48 @2 +@55 := @54 @22 +@56 := @55 @23 +@57 := Nat +@58 := List.{0} +@59 := @58 @18 +@60 := @58 @19 +@61 := Eq.{1} +@62 := Option.{0} +@63 := @62 @60 +@64 := @61 @63 +@65 := LexLeanPreservation.Rust.adtFields +@66 := #6 +@67 := @65 @66 +@68 := #3 +@71 := @64 (@67 @68 @28) +@72 := Option.some.{0} +@73 := @72 @60 +@74 := @73 @4 +@75 := @71 @74 +@76 := #7 +@78 := @27 @76 @66 +@79 := #5 +@82 := @78 @79 @28 @30 +@83 := #8 +@86 := @7 @83 @76 @66 +@87 := LexLeanTarget.TargetSyntax.Value.adt +@88 := #4 +@90 := @87 @88 @68 +@91 := @86 @90 +@92 := @8 @79 +@102 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {i : @57} -> {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @75) -> (hf : @82) -> @91 @92 +@104 := LexLeanPreservation.Rust.wt_adt @0 +@105 := @65 @0 +@109 := @64 (@105 @68 @28) @74 +@113 := @40 @66 @79 @28 @30 +@125 := {c : @25} -> + {A : @26} -> + {i : @57} -> + {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @113) -> @11 @76 @66 @90 @92 +@126 := @104 @1 +@129 := @48 @79 @28 @30 +@139 := {A : @26} -> + {i : @57} -> + {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @129) -> @12 @66 @90 @92 +@140 := @126 @2 +@142 := @54 @28 @30 +@143 := @13 @90 +@150 := {i : @57} -> {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @142) -> @143 @92 +@151 := @140 @9 +@152 := @105 @9 +@161 := {k : @57} -> + {fs : @59} -> {tys : @60} -> (h : @64 (@152 @28) @74) -> (hf : @142) -> @143 @10 +@162 := @151 @9 +@163 := @152 @9 +@164 := @64 @163 +@165 := @164 @74 +@166 := @87 @9 +@173 := {fs : @59} -> {tys : @60} -> (h : @165) -> (hf : @142) -> @13 (@166 @68) @10 +@174 := @162 @22 +@175 := @55 @30 +@178 := @13 (@166 @22) @10 +@181 := {tys : @60} -> (h : @165) -> (hf : @175) -> @178 +@182 := @174 @23 +@183 := @73 @23 +@186 := (h : @164 @183) -> (hf : @56) -> @178 +@187 := Eq.refl.{1} +@188 := @187 @63 +@191 := @182 (@188 @163) @53 +@192 := 1 +@193 := @151 @192 +@194 := @152 @192 +@195 := @64 @194 +@196 := @195 @74 +@197 := @87 @192 +@204 := {fs : @59} -> {tys : @60} -> (h : @196) -> (hf : @142) -> @13 (@197 @68) @10 +@205 := @193 @22 +@208 := @13 (@197 @22) @10 +@211 := {tys : @60} -> (h : @196) -> (hf : @175) -> @208 +@212 := @205 @23 +@215 := (h : @195 @183) -> (hf : @56) -> @208 +@218 := @212 (@188 @194) @53 +@219 := 2 +@220 := @151 @219 +@221 := @152 @219 +@222 := @64 @221 +@223 := @222 @74 +@224 := @87 @219 +@231 := {fs : @59} -> {tys : @60} -> (h : @223) -> (hf : @142) -> @13 (@224 @68) @10 +@232 := @220 @22 +@235 := @13 (@224 @22) @10 +@238 := {tys : @60} -> (h : @223) -> (hf : @175) -> @235 +@239 := @232 @23 +@242 := (h : @222 @183) -> (hf : @56) -> @235 +@245 := @239 (@188 @221) @53 +@246 := 3 +@247 := @151 @246 +@248 := @152 @246 +@249 := @64 @248 +@250 := @249 @74 +@251 := @87 @246 +@258 := {fs : @59} -> {tys : @60} -> (h : @250) -> (hf : @142) -> @13 (@251 @68) @10 +@259 := @247 @22 +@262 := @13 (@251 @22) @10 +@265 := {tys : @60} -> (h : @250) -> (hf : @175) -> @262 +@266 := @259 @23 +@269 := (h : @249 @183) -> (hf : @56) -> @262 +@272 := @266 (@188 @248) @53 +@273 := 4 +@274 := @151 @273 +@275 := @152 @273 +@276 := @64 @275 +@277 := @276 @74 +@278 := @87 @273 +@285 := {fs : @59} -> {tys : @60} -> (h : @277) -> (hf : @142) -> @13 (@278 @68) @10 +@286 := @274 @22 +@289 := @13 (@278 @22) @10 +@292 := {tys : @60} -> (h : @277) -> (hf : @175) -> @289 +@293 := @286 @23 +@296 := (h : @276 @183) -> (hf : @56) -> @289 +@299 := @293 (@188 @275) @53 +@300 := 5 +@301 := @151 @300 +@302 := @152 @300 +@303 := @64 @302 +@304 := @303 @74 +@305 := @87 @300 +@312 := {fs : @59} -> {tys : @60} -> (h : @304) -> (hf : @142) -> @13 (@305 @68) @10 +@313 := @301 @22 +@316 := @13 (@305 @22) @10 +@319 := {tys : @60} -> (h : @304) -> (hf : @175) -> @316 +@320 := @313 @23 +@323 := (h : @303 @183) -> (hf : @56) -> @316 +@326 := @320 (@188 @302) @53 +@327 := 6 +@328 := @151 @327 +@329 := @152 @327 +@330 := @64 @329 +@331 := @330 @74 +@332 := @87 @327 +@339 := {fs : @59} -> {tys : @60} -> (h : @331) -> (hf : @142) -> @13 (@332 @68) @10 +@340 := @328 @22 +@343 := @13 (@332 @22) @10 +@346 := {tys : @60} -> (h : @331) -> (hf : @175) -> @343 +@347 := @340 @23 +@350 := (h : @330 @183) -> (hf : @56) -> @343 +@353 := @347 (@188 @329) @53 +@354 := 7 +@355 := @151 @354 +@356 := @152 @354 +@357 := @64 @356 +@358 := @357 @74 +@359 := @87 @354 +@366 := {fs : @59} -> {tys : @60} -> (h : @358) -> (hf : @142) -> @13 (@359 @68) @10 +@367 := @355 @22 +@370 := @13 (@359 @22) @10 +@373 := {tys : @60} -> (h : @358) -> (hf : @175) -> @370 +@374 := @367 @23 +@377 := (h : @357 @183) -> (hf : @56) -> @370 +@380 := @374 (@188 @356) @53 +@381 := 8 +@382 := @151 @381 +@383 := @152 @381 +@384 := @64 @383 +@385 := @384 @74 +@386 := @87 @381 +@393 := {fs : @59} -> {tys : @60} -> (h : @385) -> (hf : @142) -> @13 (@386 @68) @10 +@394 := @382 @22 +@397 := @13 (@386 @22) @10 +@400 := {tys : @60} -> (h : @385) -> (hf : @175) -> @397 +@401 := @394 @23 +@404 := (h : @384 @183) -> (hf : @56) -> @397 +@407 := @401 (@188 @383) @53 +@408 := 9 +@409 := @151 @408 +@410 := @152 @408 +@411 := @64 @410 +@412 := @411 @74 +@413 := @87 @408 +@420 := {fs : @59} -> {tys : @60} -> (h : @412) -> (hf : @142) -> @13 (@413 @68) @10 +@421 := @409 @22 +@424 := @13 (@413 @22) @10 +@427 := {tys : @60} -> (h : @412) -> (hf : @175) -> @424 +@428 := @421 @23 +@431 := (h : @411 @183) -> (hf : @56) -> @424 +@434 := @428 (@188 @410) @53 +@448 := fun (__v : @3) => + Models.Glyphs.Glyph.casesOn.{0} @17 @4 @191 @218 @245 @272 @299 @326 @353 @380 @407 @434 +@449 := @5 @30 +@451 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.__wt_0 @30 +@452 := @21 @18 +@454 := @452 @449 @22 +@457 := Prod.{0, 0} @57 @18 +@461 := Prod.mk.{0, 0} @57 @18 @9 +@462 := @461 @449 +@463 := @20 @457 +@464 := @21 @457 +@466 := @464 @462 @463 +@467 := Bool.true +@468 := LexLeanTarget.TargetSyntax.Function +@469 := LexLeanTarget.TargetSyntax.Program.functions +@470 := @469 @0 +@471 := @20 @57 +@472 := LexLeanTarget.TargetSyntax.Ty.unit +@473 := LexLeanTarget.TargetSyntax.Value.unit +@476 := LexLeanTarget.TargetSyntax.Expr.value @472 @473 +@481 := LexLeanTarget.TargetSyntax.Function.mk @471 @23 @472 @476 +@486 := List.getD.{0} @468 @470 @9 @481 +@490 := fun (__e_n : @57) => LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.root @4 @9 +@495 := @7 @66 @79 @88 @68 @28 +@498 := @27 @83 @76 @66 +@500 := @452 @79 @68 +@501 := @498 @500 +@502 := @21 @19 +@504 := @502 @88 @28 +@514 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {v : @18} -> {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @495) -> (hs : @82) -> @501 @504 +@516 := LexLeanPreservation.Rust.wtl_cons @0 +@532 := {c : @25} -> + {A : @26} -> + {v : @18} -> + {t : @19} -> + {vs : @59} -> {ts : @60} -> (h : @11 @79 @88 @68 @28) -> (hs : @113) -> @40 @76 @66 @500 @504 +@533 := @516 @1 +@546 := {A : @26} -> + {v : @18} -> + {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @12 @88 @68 @28) -> (hs : @129) -> @48 @66 @500 @504 +@547 := @533 @2 +@557 := {v : @18} -> + {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @13 @68 @28) -> (hs : @142) -> @54 @500 @504 +@558 := @547 @449 +@559 := @5 @88 +@561 := @13 @559 @28 +@562 := @5 @66 +@563 := @452 @562 +@571 := {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @561) -> (hs : @142) -> @54 (@563 @68) @504 +@572 := @558 @10 +@573 := @5 @68 +@575 := @13 @573 @10 +@576 := @5 @79 +@577 := @452 @576 +@579 := @54 (@577 @68) +@580 := @502 @10 +@581 := @580 @28 +@586 := {vs : @59} -> {ts : @60} -> (h : @575) -> (hs : @142) -> @579 @581 +@587 := @572 @22 +@588 := @5 @28 +@590 := @13 @588 @10 +@592 := @452 @559 @22 +@593 := @54 @592 +@597 := {ts : @60} -> (h : @590) -> (hs : @175) -> @593 @581 +@598 := @587 @23 +@600 := @13 @449 @10 +@602 := @452 @573 @22 +@603 := @54 @602 +@604 := @580 @23 +@607 := (h : @600) -> (hs : @56) -> @603 @604 +@608 := @598 @451 +@610 := @452 @588 @22 +@611 := @54 @610 +@613 := (hs : @56) -> @611 @604 +@614 := @608 @53 +@615 := @54 @454 +@616 := @615 @604 +@617 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.denote +@618 := @617 @30 +@619 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.__fits_0 +@620 := @619 @30 +@622 := Models.Main.classify @30 +@624 := LexLeanTarget.TargetSyntax.Value.nat @622 +@626 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.root @30 +@627 := Bool +@628 := Ne.{1} +@629 := LexLeanPreservation.Obs +@630 := @628 @629 +@631 := LexLeanPreservation.Rel +@634 := @630 (@631 @30 @4) +@635 := LexLeanPreservation.Obs.stuck +@638 := (f : @627) -> (v : @18) -> @634 @635 +@640 := LexLeanPreservation.Rust.rel_ne_stuck @620 +@646 := (v : @18) -> @630 (@631 (@619 @28) @4) @635 +@647 := @640 @624 +@651 := @630 (@631 @620 @624) @635 +@652 := @58 @457 +@653 := LexLeanPreservation.Rust.FunSem +@654 := #9 +@660 := (n : @57) -> @653 @654 @83 @76 @4 @66 +@661 := @62 @468 +@662 := @61 @661 +@669 := LexLeanRuntime.index (@58 @468) @468 (LexLeanRuntime.instIndexableList @468) +@673 := @662 (@669 (@469 @654) @66) +@674 := @72 @468 +@675 := @674 @79 +@676 := @673 @675 +@677 := #10 +@681 := @27 @677 @654 @83 @79 +@682 := LexLeanTarget.TargetSyntax.Function.types +@683 := @682 @66 +@684 := @681 @683 +@685 := @62 @652 +@686 := @61 @685 +@687 := LexLeanTarget.TargetSemantics.bindAll +@688 := LexLeanTarget.TargetSyntax.Function.parameters +@693 := @686 (@687 (@688 @76) @66 @463) +@694 := @72 @652 +@695 := @694 @79 +@696 := @693 @695 +@697 := @62 @627 +@698 := @61 @697 +@699 := LexLeanPreservation.Rust.fnFallible +@700 := #11 +@703 := @698 (@699 @700 @654) +@704 := @72 @627 +@705 := @704 @79 +@706 := @703 @705 +@707 := LexLeanPreservation.RunConv +@708 := #13 +@712 := @707 @708 @677 @83 @79 +@714 := @630 @66 @635 +@715 := Exists.{1} +@716 := LexLeanPreservation.Rust.ROut +@717 := @715 @716 +@718 := And +@719 := LexLeanPreservation.Rust.RealizesFn +@723 := @718 (@719 @654 @83 @4) +@724 := LexLeanPreservation.Rust.RCI +@726 := @724 #15 +@727 := LexLeanPreservation.Rust.fnIdent +@728 := @727 @708 +@735 := (hne : @714) -> @717 (fun (ro : @716) => @723 (@726 @728 @700 @4)) +@750 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {f : @57} -> + {fn : @468} -> + {args : @59} -> + {env : @652} -> + {F : @627} -> + {o : @629} -> + (hB : @660) -> + (hfn : @676) -> (hwt : @684) -> (hbind : @696) -> (hF : @706) -> (hA : @712) -> @735 +@752 := LexLeanPreservation.Rust.compose @0 +@753 := @653 @0 +@758 := (n : @57) -> @753 @83 @76 @4 @66 +@759 := @669 @470 +@762 := @662 (@759 @66) @675 +@766 := @40 @654 @83 @79 @683 +@767 := @707 @0 +@770 := @767 @677 @83 @79 +@784 := {c : @25} -> + {A : @26} -> + {f : @57} -> + {fn : @468} -> + {args : @59} -> + {env : @652} -> + {F : @627} -> + {o : @629} -> + (hB : @758) -> + (hfn : @762) -> (hwt : @766) -> (hbind : @696) -> (hF : @706) -> (hA : @770) -> @735 +@785 := @752 @1 +@786 := @753 @1 +@790 := (n : @57) -> @786 @76 @4 @66 +@793 := @48 @83 @79 @683 +@794 := @699 @1 +@797 := @698 (@794 @654) @705 +@798 := @724 @1 +@808 := (hbind : @696) -> + (hF : @797) -> (hA : @770) -> (hne : @714) -> @717 (fun (ro : @716) => @723 (@798 @728 @700 @4)) +@818 := {A : @26} -> + {f : @57} -> + {fn : @468} -> + {args : @59} -> + {env : @652} -> {F : @627} -> {o : @629} -> (hB : @790) -> (hfn : @762) -> (hwt : @793) -> @808 +@819 := @785 @2 +@821 := @786 @2 @4 +@823 := (n : @57) -> @821 @66 +@824 := @54 @79 +@825 := @824 @683 +@834 := {f : @57} -> + {fn : @468} -> + {args : @59} -> + {env : @652} -> {F : @627} -> {o : @629} -> (hB : @823) -> (hfn : @762) -> (hwt : @825) -> @808 +@835 := @819 @9 +@837 := (n : @57) -> @821 @9 +@838 := @759 @9 +@839 := @662 @838 +@840 := @839 @675 +@841 := @794 @9 +@842 := @698 @841 +@843 := @842 @705 +@844 := @767 @9 +@846 := @844 @83 @79 +@848 := @798 (@727 @9) +@856 := (hF : @843) -> (hA : @846) -> (hne : @714) -> @717 (fun (ro : @716) => @723 (@848 @700 @4)) +@865 := {fn : @468} -> + {args : @59} -> + {env : @652} -> + {F : @627} -> {o : @629} -> (hB : @837) -> (hfn : @840) -> (hwt : @825) -> (hbind : @696) -> @856 +@866 := @835 @486 +@868 := @839 (@674 @486) +@869 := @682 @486 +@870 := @824 @869 +@872 := @687 (@688 @486) +@884 := {args : @59} -> + {env : @652} -> + {F : @627} -> + {o : @629} -> + (hB : @837) -> (hfn : @868) -> (hwt : @870) -> (hbind : @686 (@872 @66 @463) @695) -> @856 +@885 := @866 @454 +@886 := @563 @22 +@888 := @54 @886 @869 +@891 := @452 (@5 @76) @22 +@895 := @686 (@872 @891 @463) @695 +@898 := @452 (@5 @654) @22 +@919 := {env : @652} -> + {F : @627} -> + {o : @629} -> + (hB : @837) -> + (hfn : @868) -> + (hwt : @888) -> + (hbind : @895) -> + (hF : @843) -> + (hA : @844 @898 @79) -> + (hne : @714) -> @717 (fun (ro : @716) => @723 (@848 (@452 (@5 #12) @22) @4)) +@920 := @885 @466 +@921 := @577 @22 +@923 := @54 @921 @869 +@931 := @686 (@872 @886 @463) (@694 (@464 (@461 @562) @463)) +@934 := @452 (@5 @83) @22 +@953 := {F : @627} -> + {o : @629} -> + (hB : @837) -> + (hfn : @868) -> + (hwt : @923) -> + (hbind : @931) -> + (hF : @843) -> + (hA : @844 @934 @79) -> + (hne : @714) -> @717 (fun (ro : @716) => @723 (@848 (@452 (@5 @700) @22) @4)) +@954 := @920 @467 +@955 := @593 @869 +@963 := @686 (@872 @921 @463) (@694 (@464 (@461 @576) @463)) +@965 := @842 (@704 @467) +@967 := @844 @891 @79 +@968 := @719 @467 +@987 := {o : @629} -> + (hB : @837) -> + (hfn : @868) -> + (hwt : @955) -> + (hbind : @963) -> + (hF : @965) -> + (hA : @967) -> + (hne : @714) -> @717 (fun (ro : @716) => @718 (@968 @83 @4) (@848 (@452 (@5 @677) @22) @4)) +@988 := @954 @618 +@989 := @603 @869 +@997 := @686 (@872 @592 @463) (@694 (@464 (@461 @559) @463)) +@998 := @844 @886 +@999 := @617 @66 +@1000 := @998 @999 +@1001 := @617 @76 +@1019 := (hB : @837) -> + (hfn : @868) -> + (hwt : @989) -> + (hbind : @997) -> + (hF : @965) -> + (hA : @1000) -> + (hne : @630 @1001 @635) -> @717 (fun (ro : @716) => @718 (@968 (@617 @654) @4) (@848 @898 @4)) +@1020 := @988 @490 +@1021 := @611 @869 +@1029 := @686 (@872 @602 @463) (@694 (@464 (@461 @573) @463)) +@1030 := @844 @921 +@1031 := @617 @79 +@1049 := (hfn : @868) -> + (hwt : @1021) -> + (hbind : @1029) -> + (hF : @965) -> + (hA : @1030 @1031) -> + (hne : @630 @999 @635) -> @717 (fun (ro : @716) => @718 (@968 (@617 @83) @4) (@848 @934 @4)) +@1052 := @1020 (@187 @661 @838) +@1053 := @615 @869 +@1061 := @686 (@872 @610 @463) (@694 (@464 (@461 @588) @463)) +@1062 := @844 @592 +@1063 := @617 @88 +@1079 := (hwt : @1053) -> + (hbind : @1061) -> + (hF : @965) -> + (hA : @1062 @1063) -> + (hne : @630 @1031 @635) -> @717 (fun (ro : @716) => @718 (@968 @1001 @4) (@848 @891 @4)) +@1080 := @1052 @614 +@1082 := @872 @454 @463 +@1085 := @686 @1082 (@694 @466) +@1086 := @844 @602 +@1087 := @617 @68 +@1102 := (hbind : @1085) -> + (hF : @965) -> + (hA : @1086 @1087) -> + (hne : @630 @1063 @635) -> @717 (fun (ro : @716) => @718 (@968 @999 @4) (@848 @886 @4)) +@1105 := @1080 (@187 @685 @1082) +@1106 := @844 @610 +@1107 := @617 @28 +@1121 := (hF : @965) -> + (hA : @1106 @1107) -> + (hne : @630 @1087 @635) -> @717 (fun (ro : @716) => @718 (@968 @1031 @4) (@848 @921 @4)) +@1124 := @1105 (@187 @697 @841) +@1138 := (hA : @844 @454 @618) -> + (hne : @630 @1107 @635) -> @717 (fun (ro : @716) => @718 (@968 @1063 @4) (@848 @592 @4)) +@1139 := @1124 @626 +@1150 := (hne : @630 @618 @635) -> @717 (fun (ro : @716) => @718 (@968 @1087 @4) (@848 @602 @4)) +@1151 := @1139 @647 +@1157 := @718 (@968 @1107 @4) (@848 @610 @4) +@1159 := @717 (fun (ro : @716) => @1157) +@1161 := @717 (fun (__e_ro : @716) => @1157) +@1165 := LexLeanPreservation.Rust.RepresentableL (@452 @6 @22) +@1166 := (__e_hrep : @1165) -> @1161 +@1167 := fun (__e_hrep : @1165) => @1151 +@1168 := (glyph : @3) -> @1166 +@1169 := fun (glyph : @3) => @1167 +\end{coremodule} +\end{lexlean} diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R1/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R1/Compose/RustStd.lean deleted file mode 100644 index f0fbdade9..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R1/Compose/RustStd.lean +++ /dev/null @@ -1,28 +0,0 @@ -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1 -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Models.Glyphs.Glyph)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.program _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.krate _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.flags (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.__enc_0 __v) (.adt 0) - | Models.Glyphs.Glyph.g0 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g1 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g2 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g3 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g4 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g5 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g6 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g7 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g8 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Glyphs.Glyph.g9 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (glyph : (Models.Glyphs.Glyph)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.__enc_0 glyph)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.denote glyph) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.__enc_0 glyph)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 glyph) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.root glyph) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R1/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R1/Compose/RustStd.lex.tex new file mode 100644 index 000000000..b85bb0449 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R1/Compose/RustStd.lex.tex @@ -0,0 +1,590 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1, + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.__wt_0 : @16 := @448 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.root : @1181 := @1182 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.program +@1 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.krate +@2 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.flags +@3 := Models.Glyphs.Glyph +@4 := #0 +@5 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := (__v : @3) -> @15 +@17 := fun (__v : @3) => @15 +@18 := LexLeanTarget.TargetSyntax.Value +@19 := LexLeanTarget.TargetSyntax.Ty +@20 := List.nil.{0} +@21 := List.cons.{0} +@22 := @20 @18 +@23 := @20 @19 +@24 := LexLeanTarget.TargetSyntax.Program +@25 := LexLeanPreservation.Rust.RCrate +@26 := LexLeanPreservation.Rust.Flags +@27 := LexLeanPreservation.Rust.WTL +@28 := #2 +@29 := @27 @28 +@30 := #1 +@37 := {p : @24} -> {c : @25} -> {A : @26} -> @29 @30 @4 @22 @23 +@39 := LexLeanPreservation.Rust.wtl_nil @0 +@40 := @27 @0 +@46 := {c : @25} -> {A : @26} -> @40 @30 @4 @22 @23 +@47 := @39 @1 +@48 := @40 @1 +@52 := {A : @26} -> @48 @4 @22 @23 +@53 := @47 @2 +@54 := @48 @2 +@55 := @54 @22 +@56 := @55 @23 +@57 := Nat +@58 := List.{0} +@59 := @58 @18 +@60 := @58 @19 +@61 := Eq.{1} +@62 := Option.{0} +@63 := @62 @60 +@64 := @61 @63 +@65 := LexLeanPreservation.Rust.adtFields +@66 := #6 +@67 := @65 @66 +@68 := #3 +@71 := @64 (@67 @68 @28) +@72 := Option.some.{0} +@73 := @72 @60 +@74 := @73 @4 +@75 := @71 @74 +@76 := #7 +@78 := @27 @76 @66 +@79 := #5 +@82 := @78 @79 @28 @30 +@83 := #8 +@86 := @7 @83 @76 @66 +@87 := LexLeanTarget.TargetSyntax.Value.adt +@88 := #4 +@90 := @87 @88 @68 +@91 := @86 @90 +@92 := @8 @79 +@102 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {i : @57} -> {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @75) -> (hf : @82) -> @91 @92 +@104 := LexLeanPreservation.Rust.wt_adt @0 +@105 := @65 @0 +@109 := @64 (@105 @68 @28) @74 +@113 := @40 @66 @79 @28 @30 +@125 := {c : @25} -> + {A : @26} -> + {i : @57} -> + {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @113) -> @11 @76 @66 @90 @92 +@126 := @104 @1 +@129 := @48 @79 @28 @30 +@139 := {A : @26} -> + {i : @57} -> + {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @129) -> @12 @66 @90 @92 +@140 := @126 @2 +@142 := @54 @28 @30 +@143 := @13 @90 +@150 := {i : @57} -> {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @142) -> @143 @92 +@151 := @140 @9 +@152 := @105 @9 +@161 := {k : @57} -> + {fs : @59} -> {tys : @60} -> (h : @64 (@152 @28) @74) -> (hf : @142) -> @143 @10 +@162 := @151 @9 +@163 := @152 @9 +@164 := @64 @163 +@165 := @164 @74 +@166 := @87 @9 +@173 := {fs : @59} -> {tys : @60} -> (h : @165) -> (hf : @142) -> @13 (@166 @68) @10 +@174 := @162 @22 +@175 := @55 @30 +@178 := @13 (@166 @22) @10 +@181 := {tys : @60} -> (h : @165) -> (hf : @175) -> @178 +@182 := @174 @23 +@183 := @73 @23 +@186 := (h : @164 @183) -> (hf : @56) -> @178 +@187 := Eq.refl.{1} +@188 := @187 @63 +@191 := @182 (@188 @163) @53 +@192 := 1 +@193 := @151 @192 +@194 := @152 @192 +@195 := @64 @194 +@196 := @195 @74 +@197 := @87 @192 +@204 := {fs : @59} -> {tys : @60} -> (h : @196) -> (hf : @142) -> @13 (@197 @68) @10 +@205 := @193 @22 +@208 := @13 (@197 @22) @10 +@211 := {tys : @60} -> (h : @196) -> (hf : @175) -> @208 +@212 := @205 @23 +@215 := (h : @195 @183) -> (hf : @56) -> @208 +@218 := @212 (@188 @194) @53 +@219 := 2 +@220 := @151 @219 +@221 := @152 @219 +@222 := @64 @221 +@223 := @222 @74 +@224 := @87 @219 +@231 := {fs : @59} -> {tys : @60} -> (h : @223) -> (hf : @142) -> @13 (@224 @68) @10 +@232 := @220 @22 +@235 := @13 (@224 @22) @10 +@238 := {tys : @60} -> (h : @223) -> (hf : @175) -> @235 +@239 := @232 @23 +@242 := (h : @222 @183) -> (hf : @56) -> @235 +@245 := @239 (@188 @221) @53 +@246 := 3 +@247 := @151 @246 +@248 := @152 @246 +@249 := @64 @248 +@250 := @249 @74 +@251 := @87 @246 +@258 := {fs : @59} -> {tys : @60} -> (h : @250) -> (hf : @142) -> @13 (@251 @68) @10 +@259 := @247 @22 +@262 := @13 (@251 @22) @10 +@265 := {tys : @60} -> (h : @250) -> (hf : @175) -> @262 +@266 := @259 @23 +@269 := (h : @249 @183) -> (hf : @56) -> @262 +@272 := @266 (@188 @248) @53 +@273 := 4 +@274 := @151 @273 +@275 := @152 @273 +@276 := @64 @275 +@277 := @276 @74 +@278 := @87 @273 +@285 := {fs : @59} -> {tys : @60} -> (h : @277) -> (hf : @142) -> @13 (@278 @68) @10 +@286 := @274 @22 +@289 := @13 (@278 @22) @10 +@292 := {tys : @60} -> (h : @277) -> (hf : @175) -> @289 +@293 := @286 @23 +@296 := (h : @276 @183) -> (hf : @56) -> @289 +@299 := @293 (@188 @275) @53 +@300 := 5 +@301 := @151 @300 +@302 := @152 @300 +@303 := @64 @302 +@304 := @303 @74 +@305 := @87 @300 +@312 := {fs : @59} -> {tys : @60} -> (h : @304) -> (hf : @142) -> @13 (@305 @68) @10 +@313 := @301 @22 +@316 := @13 (@305 @22) @10 +@319 := {tys : @60} -> (h : @304) -> (hf : @175) -> @316 +@320 := @313 @23 +@323 := (h : @303 @183) -> (hf : @56) -> @316 +@326 := @320 (@188 @302) @53 +@327 := 6 +@328 := @151 @327 +@329 := @152 @327 +@330 := @64 @329 +@331 := @330 @74 +@332 := @87 @327 +@339 := {fs : @59} -> {tys : @60} -> (h : @331) -> (hf : @142) -> @13 (@332 @68) @10 +@340 := @328 @22 +@343 := @13 (@332 @22) @10 +@346 := {tys : @60} -> (h : @331) -> (hf : @175) -> @343 +@347 := @340 @23 +@350 := (h : @330 @183) -> (hf : @56) -> @343 +@353 := @347 (@188 @329) @53 +@354 := 7 +@355 := @151 @354 +@356 := @152 @354 +@357 := @64 @356 +@358 := @357 @74 +@359 := @87 @354 +@366 := {fs : @59} -> {tys : @60} -> (h : @358) -> (hf : @142) -> @13 (@359 @68) @10 +@367 := @355 @22 +@370 := @13 (@359 @22) @10 +@373 := {tys : @60} -> (h : @358) -> (hf : @175) -> @370 +@374 := @367 @23 +@377 := (h : @357 @183) -> (hf : @56) -> @370 +@380 := @374 (@188 @356) @53 +@381 := 8 +@382 := @151 @381 +@383 := @152 @381 +@384 := @64 @383 +@385 := @384 @74 +@386 := @87 @381 +@393 := {fs : @59} -> {tys : @60} -> (h : @385) -> (hf : @142) -> @13 (@386 @68) @10 +@394 := @382 @22 +@397 := @13 (@386 @22) @10 +@400 := {tys : @60} -> (h : @385) -> (hf : @175) -> @397 +@401 := @394 @23 +@404 := (h : @384 @183) -> (hf : @56) -> @397 +@407 := @401 (@188 @383) @53 +@408 := 9 +@409 := @151 @408 +@410 := @152 @408 +@411 := @64 @410 +@412 := @411 @74 +@413 := @87 @408 +@420 := {fs : @59} -> {tys : @60} -> (h : @412) -> (hf : @142) -> @13 (@413 @68) @10 +@421 := @409 @22 +@424 := @13 (@413 @22) @10 +@427 := {tys : @60} -> (h : @412) -> (hf : @175) -> @424 +@428 := @421 @23 +@431 := (h : @411 @183) -> (hf : @56) -> @424 +@434 := @428 (@188 @410) @53 +@448 := fun (__v : @3) => + Models.Glyphs.Glyph.casesOn.{0} @17 @4 @191 @218 @245 @272 @299 @326 @353 @380 @407 @434 +@449 := @5 @30 +@451 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.__wt_0 @30 +@452 := @21 @18 +@454 := @452 @449 @22 +@455 := Prod.{0, 0} +@457 := @455 @57 @18 +@461 := Prod.mk.{0, 0} @57 @18 @9 +@462 := @461 @449 +@463 := @20 @457 +@464 := @21 @457 +@466 := @464 @462 @463 +@467 := Bool.true +@468 := LexLeanTarget.TargetSyntax.Function +@469 := LexLeanTarget.TargetSyntax.Program.functions +@470 := @469 @0 +@471 := @20 @57 +@472 := LexLeanTarget.TargetSyntax.Ty.unit +@473 := LexLeanTarget.TargetSyntax.Value.unit +@476 := LexLeanTarget.TargetSyntax.Expr.value @472 @473 +@481 := LexLeanTarget.TargetSyntax.Function.mk @471 @23 @472 @476 +@486 := List.getD.{0} @468 @470 @9 @481 +@490 := fun (__e_n : @57) => LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.root @4 @9 +@495 := @7 @66 @79 @88 @68 @28 +@498 := @27 @83 @76 @66 +@500 := @452 @79 @68 +@501 := @498 @500 +@502 := @21 @19 +@504 := @502 @88 @28 +@514 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {v : @18} -> {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @495) -> (hs : @82) -> @501 @504 +@516 := LexLeanPreservation.Rust.wtl_cons @0 +@532 := {c : @25} -> + {A : @26} -> + {v : @18} -> + {t : @19} -> + {vs : @59} -> {ts : @60} -> (h : @11 @79 @88 @68 @28) -> (hs : @113) -> @40 @76 @66 @500 @504 +@533 := @516 @1 +@546 := {A : @26} -> + {v : @18} -> + {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @12 @88 @68 @28) -> (hs : @129) -> @48 @66 @500 @504 +@547 := @533 @2 +@557 := {v : @18} -> + {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @13 @68 @28) -> (hs : @142) -> @54 @500 @504 +@558 := @547 @449 +@559 := @5 @88 +@561 := @13 @559 @28 +@562 := @5 @66 +@563 := @452 @562 +@571 := {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @561) -> (hs : @142) -> @54 (@563 @68) @504 +@572 := @558 @10 +@573 := @5 @68 +@575 := @13 @573 @10 +@576 := @5 @79 +@577 := @452 @576 +@579 := @54 (@577 @68) +@580 := @502 @10 +@581 := @580 @28 +@586 := {vs : @59} -> {ts : @60} -> (h : @575) -> (hs : @142) -> @579 @581 +@587 := @572 @22 +@588 := @5 @28 +@590 := @13 @588 @10 +@592 := @452 @559 @22 +@593 := @54 @592 +@597 := {ts : @60} -> (h : @590) -> (hs : @175) -> @593 @581 +@598 := @587 @23 +@600 := @13 @449 @10 +@602 := @452 @573 @22 +@603 := @54 @602 +@604 := @580 @23 +@607 := (h : @600) -> (hs : @56) -> @603 @604 +@608 := @598 @451 +@610 := @452 @588 @22 +@611 := @54 @610 +@613 := (hs : @56) -> @611 @604 +@614 := @608 @53 +@615 := @54 @454 +@616 := @615 @604 +@617 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.denote +@618 := @617 @30 +@619 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.__fits_0 +@620 := @619 @30 +@622 := Models.Main.classifyChecked @30 +@623 := Bool +@625 := @455 @623 @623 +@626 := LexLeanTarget.TargetSyntax.Value.bool +@631 := LexLeanPreservation.encPair @623 @623 @626 @626 +@632 := LexLeanTarget.TargetSyntax.Value.nat +@638 := LexLeanPreservation.encExcept @625 @57 @631 @632 @622 +@640 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.root @30 +@641 := Ne.{1} +@642 := LexLeanPreservation.Obs +@643 := @641 @642 +@644 := LexLeanPreservation.Rel +@647 := @643 (@644 @30 @4) +@648 := LexLeanPreservation.Obs.stuck +@651 := (f : @623) -> (v : @18) -> @647 @648 +@653 := LexLeanPreservation.Rust.rel_ne_stuck @620 +@659 := (v : @18) -> @643 (@644 (@619 @28) @4) @648 +@660 := @653 @638 +@664 := @643 (@644 @620 @638) @648 +@665 := @58 @457 +@666 := LexLeanPreservation.Rust.FunSem +@667 := #9 +@673 := (n : @57) -> @666 @667 @83 @76 @4 @66 +@674 := @62 @468 +@675 := @61 @674 +@682 := LexLeanRuntime.index (@58 @468) @468 (LexLeanRuntime.instIndexableList @468) +@686 := @675 (@682 (@469 @667) @66) +@687 := @72 @468 +@688 := @687 @79 +@689 := @686 @688 +@690 := #10 +@694 := @27 @690 @667 @83 @79 +@695 := LexLeanTarget.TargetSyntax.Function.types +@696 := @695 @66 +@697 := @694 @696 +@698 := @62 @665 +@699 := @61 @698 +@700 := LexLeanTarget.TargetSemantics.bindAll +@701 := LexLeanTarget.TargetSyntax.Function.parameters +@706 := @699 (@700 (@701 @76) @66 @463) +@707 := @72 @665 +@708 := @707 @79 +@709 := @706 @708 +@710 := @62 @623 +@711 := @61 @710 +@712 := LexLeanPreservation.Rust.fnFallible +@713 := #11 +@716 := @711 (@712 @713 @667) +@717 := @72 @623 +@718 := @717 @79 +@719 := @716 @718 +@720 := LexLeanPreservation.RunConv +@721 := #13 +@725 := @720 @721 @690 @83 @79 +@727 := @643 @66 @648 +@728 := Exists.{1} +@729 := LexLeanPreservation.Rust.ROut +@730 := @728 @729 +@731 := And +@732 := LexLeanPreservation.Rust.RealizesFn +@736 := @731 (@732 @667 @83 @4) +@737 := LexLeanPreservation.Rust.RCI +@739 := @737 #15 +@740 := LexLeanPreservation.Rust.fnIdent +@741 := @740 @721 +@748 := (hne : @727) -> @730 (fun (ro : @729) => @736 (@739 @741 @713 @4)) +@763 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {f : @57} -> + {fn : @468} -> + {args : @59} -> + {env : @665} -> + {F : @623} -> + {o : @642} -> + (hB : @673) -> + (hfn : @689) -> (hwt : @697) -> (hbind : @709) -> (hF : @719) -> (hA : @725) -> @748 +@765 := LexLeanPreservation.Rust.compose @0 +@766 := @666 @0 +@771 := (n : @57) -> @766 @83 @76 @4 @66 +@772 := @682 @470 +@775 := @675 (@772 @66) @688 +@779 := @40 @667 @83 @79 @696 +@780 := @720 @0 +@783 := @780 @690 @83 @79 +@797 := {c : @25} -> + {A : @26} -> + {f : @57} -> + {fn : @468} -> + {args : @59} -> + {env : @665} -> + {F : @623} -> + {o : @642} -> + (hB : @771) -> + (hfn : @775) -> (hwt : @779) -> (hbind : @709) -> (hF : @719) -> (hA : @783) -> @748 +@798 := @765 @1 +@799 := @766 @1 +@803 := (n : @57) -> @799 @76 @4 @66 +@806 := @48 @83 @79 @696 +@807 := @712 @1 +@810 := @711 (@807 @667) @718 +@811 := @737 @1 +@821 := (hbind : @709) -> + (hF : @810) -> (hA : @783) -> (hne : @727) -> @730 (fun (ro : @729) => @736 (@811 @741 @713 @4)) +@831 := {A : @26} -> + {f : @57} -> + {fn : @468} -> + {args : @59} -> + {env : @665} -> {F : @623} -> {o : @642} -> (hB : @803) -> (hfn : @775) -> (hwt : @806) -> @821 +@832 := @798 @2 +@834 := @799 @2 @4 +@836 := (n : @57) -> @834 @66 +@837 := @54 @79 +@838 := @837 @696 +@847 := {f : @57} -> + {fn : @468} -> + {args : @59} -> + {env : @665} -> {F : @623} -> {o : @642} -> (hB : @836) -> (hfn : @775) -> (hwt : @838) -> @821 +@848 := @832 @9 +@850 := (n : @57) -> @834 @9 +@851 := @772 @9 +@852 := @675 @851 +@853 := @852 @688 +@854 := @807 @9 +@855 := @711 @854 +@856 := @855 @718 +@857 := @780 @9 +@859 := @857 @83 @79 +@861 := @811 (@740 @9) +@869 := (hF : @856) -> (hA : @859) -> (hne : @727) -> @730 (fun (ro : @729) => @736 (@861 @713 @4)) +@878 := {fn : @468} -> + {args : @59} -> + {env : @665} -> + {F : @623} -> {o : @642} -> (hB : @850) -> (hfn : @853) -> (hwt : @838) -> (hbind : @709) -> @869 +@879 := @848 @486 +@881 := @852 (@687 @486) +@882 := @695 @486 +@883 := @837 @882 +@885 := @700 (@701 @486) +@897 := {args : @59} -> + {env : @665} -> + {F : @623} -> + {o : @642} -> + (hB : @850) -> (hfn : @881) -> (hwt : @883) -> (hbind : @699 (@885 @66 @463) @708) -> @869 +@898 := @879 @454 +@899 := @563 @22 +@901 := @54 @899 @882 +@904 := @452 (@5 @76) @22 +@908 := @699 (@885 @904 @463) @708 +@911 := @452 (@5 @667) @22 +@932 := {env : @665} -> + {F : @623} -> + {o : @642} -> + (hB : @850) -> + (hfn : @881) -> + (hwt : @901) -> + (hbind : @908) -> + (hF : @856) -> + (hA : @857 @911 @79) -> + (hne : @727) -> @730 (fun (ro : @729) => @736 (@861 (@452 (@5 #12) @22) @4)) +@933 := @898 @466 +@934 := @577 @22 +@936 := @54 @934 @882 +@944 := @699 (@885 @899 @463) (@707 (@464 (@461 @562) @463)) +@947 := @452 (@5 @83) @22 +@966 := {F : @623} -> + {o : @642} -> + (hB : @850) -> + (hfn : @881) -> + (hwt : @936) -> + (hbind : @944) -> + (hF : @856) -> + (hA : @857 @947 @79) -> + (hne : @727) -> @730 (fun (ro : @729) => @736 (@861 (@452 (@5 @713) @22) @4)) +@967 := @933 @467 +@968 := @593 @882 +@976 := @699 (@885 @934 @463) (@707 (@464 (@461 @576) @463)) +@978 := @855 (@717 @467) +@980 := @857 @904 @79 +@981 := @732 @467 +@1000 := {o : @642} -> + (hB : @850) -> + (hfn : @881) -> + (hwt : @968) -> + (hbind : @976) -> + (hF : @978) -> + (hA : @980) -> + (hne : @727) -> @730 (fun (ro : @729) => @731 (@981 @83 @4) (@861 (@452 (@5 @690) @22) @4)) +@1001 := @967 @618 +@1002 := @603 @882 +@1010 := @699 (@885 @592 @463) (@707 (@464 (@461 @559) @463)) +@1011 := @857 @899 +@1012 := @617 @66 +@1013 := @1011 @1012 +@1014 := @617 @76 +@1032 := (hB : @850) -> + (hfn : @881) -> + (hwt : @1002) -> + (hbind : @1010) -> + (hF : @978) -> + (hA : @1013) -> + (hne : @643 @1014 @648) -> @730 (fun (ro : @729) => @731 (@981 (@617 @667) @4) (@861 @911 @4)) +@1033 := @1001 @490 +@1034 := @611 @882 +@1042 := @699 (@885 @602 @463) (@707 (@464 (@461 @573) @463)) +@1043 := @857 @934 +@1044 := @617 @79 +@1062 := (hfn : @881) -> + (hwt : @1034) -> + (hbind : @1042) -> + (hF : @978) -> + (hA : @1043 @1044) -> + (hne : @643 @1012 @648) -> @730 (fun (ro : @729) => @731 (@981 (@617 @83) @4) (@861 @947 @4)) +@1065 := @1033 (@187 @674 @851) +@1066 := @615 @882 +@1074 := @699 (@885 @610 @463) (@707 (@464 (@461 @588) @463)) +@1075 := @857 @592 +@1076 := @617 @88 +@1092 := (hwt : @1066) -> + (hbind : @1074) -> + (hF : @978) -> + (hA : @1075 @1076) -> + (hne : @643 @1044 @648) -> @730 (fun (ro : @729) => @731 (@981 @1014 @4) (@861 @904 @4)) +@1093 := @1065 @614 +@1095 := @885 @454 @463 +@1098 := @699 @1095 (@707 @466) +@1099 := @857 @602 +@1100 := @617 @68 +@1115 := (hbind : @1098) -> + (hF : @978) -> + (hA : @1099 @1100) -> + (hne : @643 @1076 @648) -> @730 (fun (ro : @729) => @731 (@981 @1012 @4) (@861 @899 @4)) +@1118 := @1093 (@187 @698 @1095) +@1119 := @857 @610 +@1120 := @617 @28 +@1134 := (hF : @978) -> + (hA : @1119 @1120) -> + (hne : @643 @1100 @648) -> @730 (fun (ro : @729) => @731 (@981 @1044 @4) (@861 @934 @4)) +@1137 := @1118 (@187 @710 @854) +@1151 := (hA : @857 @454 @618) -> + (hne : @643 @1120 @648) -> @730 (fun (ro : @729) => @731 (@981 @1076 @4) (@861 @592 @4)) +@1152 := @1137 @640 +@1163 := (hne : @643 @618 @648) -> @730 (fun (ro : @729) => @731 (@981 @1100 @4) (@861 @602 @4)) +@1164 := @1152 @660 +@1170 := @731 (@981 @1120 @4) (@861 @610 @4) +@1172 := @730 (fun (ro : @729) => @1170) +@1174 := @730 (fun (__e_ro : @729) => @1170) +@1178 := LexLeanPreservation.Rust.RepresentableL (@452 @6 @22) +@1179 := (__e_hrep : @1178) -> @1174 +@1180 := fun (__e_hrep : @1178) => @1164 +@1181 := (glyph : @3) -> @1179 +@1182 := fun (glyph : @3) => @1180 +\end{coremodule} +\end{lexlean} diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R2/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R2/Compose/RustStd.lean deleted file mode 100644 index aa04d5f8a..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R2/Compose/RustStd.lean +++ /dev/null @@ -1,31 +0,0 @@ -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2 -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Models.Triage.Presentation)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.program _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.krate _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.flags (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.__enc_0 __v) (.adt 0) - | Models.Triage.Presentation.p0 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Triage.Presentation.p1 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Triage.Presentation.p2 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Triage.Presentation.p3 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Triage.Presentation.p4 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Triage.Presentation.p5 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Triage.Presentation.p6 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Triage.Presentation.p7 => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - -theorem __wt_1 : ∀ (__v : (Models.Triage.Level)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.program _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.krate _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.flags (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.__enc_1 __v) (.adt 1) - | Models.Triage.Level.routine => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Triage.Level.urgent => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Models.Triage.Level.emergency => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (presentation : (Models.Triage.Presentation)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.__enc_0 presentation)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.denote presentation) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.__enc_0 presentation)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 presentation) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.root presentation) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R2/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R2/Compose/RustStd.lex.tex new file mode 100644 index 000000000..713e3e80c --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R2/Compose/RustStd.lex.tex @@ -0,0 +1,621 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2, + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.__wt_0 : @16 := @392 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.__wt_1 : @399 := @481 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.root : @1214 := @1215 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.program +@1 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.krate +@2 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.flags +@3 := Models.Triage.Presentation +@4 := #0 +@5 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := (__v : @3) -> @15 +@17 := fun (__v : @3) => @15 +@18 := LexLeanTarget.TargetSyntax.Value +@19 := LexLeanTarget.TargetSyntax.Ty +@20 := List.nil.{0} +@21 := List.cons.{0} +@22 := @20 @18 +@23 := @20 @19 +@24 := LexLeanTarget.TargetSyntax.Program +@25 := LexLeanPreservation.Rust.RCrate +@26 := LexLeanPreservation.Rust.Flags +@27 := LexLeanPreservation.Rust.WTL +@28 := #2 +@29 := @27 @28 +@30 := #1 +@37 := {p : @24} -> {c : @25} -> {A : @26} -> @29 @30 @4 @22 @23 +@39 := LexLeanPreservation.Rust.wtl_nil @0 +@40 := @27 @0 +@46 := {c : @25} -> {A : @26} -> @40 @30 @4 @22 @23 +@47 := @39 @1 +@48 := @40 @1 +@52 := {A : @26} -> @48 @4 @22 @23 +@53 := @47 @2 +@54 := @48 @2 +@55 := @54 @22 +@56 := @55 @23 +@57 := Nat +@58 := List.{0} +@59 := @58 @18 +@60 := @58 @19 +@61 := Eq.{1} +@62 := Option.{0} +@63 := @62 @60 +@64 := @61 @63 +@65 := LexLeanPreservation.Rust.adtFields +@66 := #6 +@67 := @65 @66 +@68 := #3 +@71 := @64 (@67 @68 @28) +@72 := Option.some.{0} +@73 := @72 @60 +@74 := @73 @4 +@75 := @71 @74 +@76 := #7 +@78 := @27 @76 @66 +@79 := #5 +@82 := @78 @79 @28 @30 +@83 := #8 +@86 := @7 @83 @76 @66 +@87 := LexLeanTarget.TargetSyntax.Value.adt +@88 := #4 +@90 := @87 @88 @68 +@91 := @86 @90 +@92 := @8 @79 +@102 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {i : @57} -> {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @75) -> (hf : @82) -> @91 @92 +@104 := LexLeanPreservation.Rust.wt_adt @0 +@105 := @65 @0 +@109 := @64 (@105 @68 @28) @74 +@113 := @40 @66 @79 @28 @30 +@125 := {c : @25} -> + {A : @26} -> + {i : @57} -> + {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @113) -> @11 @76 @66 @90 @92 +@126 := @104 @1 +@129 := @48 @79 @28 @30 +@139 := {A : @26} -> + {i : @57} -> + {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @129) -> @12 @66 @90 @92 +@140 := @126 @2 +@142 := @54 @28 @30 +@143 := @13 @90 +@150 := {i : @57} -> {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @142) -> @143 @92 +@151 := @140 @9 +@152 := @105 @9 +@161 := {k : @57} -> + {fs : @59} -> {tys : @60} -> (h : @64 (@152 @28) @74) -> (hf : @142) -> @143 @10 +@162 := @151 @9 +@163 := @152 @9 +@164 := @64 @163 +@165 := @164 @74 +@166 := @87 @9 +@168 := @13 (@166 @68) +@173 := {fs : @59} -> {tys : @60} -> (h : @165) -> (hf : @142) -> @168 @10 +@174 := @162 @22 +@175 := @55 @30 +@177 := @13 (@166 @22) +@178 := @177 @10 +@181 := {tys : @60} -> (h : @165) -> (hf : @175) -> @178 +@182 := @174 @23 +@183 := @73 @23 +@186 := (h : @164 @183) -> (hf : @56) -> @178 +@187 := Eq.refl.{1} +@188 := @187 @63 +@191 := @182 (@188 @163) @53 +@192 := 1 +@193 := @151 @192 +@194 := @152 @192 +@195 := @64 @194 +@196 := @195 @74 +@197 := @87 @192 +@199 := @13 (@197 @68) +@204 := {fs : @59} -> {tys : @60} -> (h : @196) -> (hf : @142) -> @199 @10 +@205 := @193 @22 +@207 := @13 (@197 @22) +@208 := @207 @10 +@211 := {tys : @60} -> (h : @196) -> (hf : @175) -> @208 +@212 := @205 @23 +@215 := (h : @195 @183) -> (hf : @56) -> @208 +@218 := @212 (@188 @194) @53 +@219 := 2 +@220 := @151 @219 +@221 := @152 @219 +@222 := @64 @221 +@223 := @222 @74 +@224 := @87 @219 +@226 := @13 (@224 @68) +@231 := {fs : @59} -> {tys : @60} -> (h : @223) -> (hf : @142) -> @226 @10 +@232 := @220 @22 +@234 := @13 (@224 @22) +@235 := @234 @10 +@238 := {tys : @60} -> (h : @223) -> (hf : @175) -> @235 +@239 := @232 @23 +@242 := (h : @222 @183) -> (hf : @56) -> @235 +@245 := @239 (@188 @221) @53 +@246 := 3 +@247 := @151 @246 +@248 := @152 @246 +@249 := @64 @248 +@250 := @249 @74 +@251 := @87 @246 +@258 := {fs : @59} -> {tys : @60} -> (h : @250) -> (hf : @142) -> @13 (@251 @68) @10 +@259 := @247 @22 +@262 := @13 (@251 @22) @10 +@265 := {tys : @60} -> (h : @250) -> (hf : @175) -> @262 +@266 := @259 @23 +@269 := (h : @249 @183) -> (hf : @56) -> @262 +@272 := @266 (@188 @248) @53 +@273 := 4 +@274 := @151 @273 +@275 := @152 @273 +@276 := @64 @275 +@277 := @276 @74 +@278 := @87 @273 +@285 := {fs : @59} -> {tys : @60} -> (h : @277) -> (hf : @142) -> @13 (@278 @68) @10 +@286 := @274 @22 +@289 := @13 (@278 @22) @10 +@292 := {tys : @60} -> (h : @277) -> (hf : @175) -> @289 +@293 := @286 @23 +@296 := (h : @276 @183) -> (hf : @56) -> @289 +@299 := @293 (@188 @275) @53 +@300 := 5 +@301 := @151 @300 +@302 := @152 @300 +@303 := @64 @302 +@304 := @303 @74 +@305 := @87 @300 +@312 := {fs : @59} -> {tys : @60} -> (h : @304) -> (hf : @142) -> @13 (@305 @68) @10 +@313 := @301 @22 +@316 := @13 (@305 @22) @10 +@319 := {tys : @60} -> (h : @304) -> (hf : @175) -> @316 +@320 := @313 @23 +@323 := (h : @303 @183) -> (hf : @56) -> @316 +@326 := @320 (@188 @302) @53 +@327 := 6 +@328 := @151 @327 +@329 := @152 @327 +@330 := @64 @329 +@331 := @330 @74 +@332 := @87 @327 +@339 := {fs : @59} -> {tys : @60} -> (h : @331) -> (hf : @142) -> @13 (@332 @68) @10 +@340 := @328 @22 +@343 := @13 (@332 @22) @10 +@346 := {tys : @60} -> (h : @331) -> (hf : @175) -> @343 +@347 := @340 @23 +@350 := (h : @330 @183) -> (hf : @56) -> @343 +@353 := @347 (@188 @329) @53 +@354 := 7 +@355 := @151 @354 +@356 := @152 @354 +@357 := @64 @356 +@358 := @357 @74 +@359 := @87 @354 +@366 := {fs : @59} -> {tys : @60} -> (h : @358) -> (hf : @142) -> @13 (@359 @68) @10 +@367 := @355 @22 +@370 := @13 (@359 @22) @10 +@373 := {tys : @60} -> (h : @358) -> (hf : @175) -> @370 +@374 := @367 @23 +@377 := (h : @357 @183) -> (hf : @56) -> @370 +@380 := @374 (@188 @356) @53 +@392 := fun (__v : @3) => + Models.Triage.Presentation.casesOn.{0} @17 @4 @191 @218 @245 @272 @299 @326 @353 @380 +@393 := Models.Triage.Level +@395 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.__enc_1 @4 +@396 := @8 @192 +@398 := @13 @395 @396 +@399 := (__v : @393) -> @398 +@400 := fun (__v : @393) => @398 +@401 := @140 @192 +@402 := @105 @192 +@411 := {k : @57} -> + {fs : @59} -> {tys : @60} -> (h : @64 (@402 @28) @74) -> (hf : @142) -> @143 @396 +@412 := @401 @9 +@413 := @402 @9 +@414 := @64 @413 +@415 := @414 @74 +@420 := {fs : @59} -> {tys : @60} -> (h : @415) -> (hf : @142) -> @168 @396 +@421 := @412 @22 +@422 := @177 @396 +@425 := {tys : @60} -> (h : @415) -> (hf : @175) -> @422 +@426 := @421 @23 +@429 := (h : @414 @183) -> (hf : @56) -> @422 +@432 := @426 (@188 @413) @53 +@433 := @401 @192 +@434 := @402 @192 +@435 := @64 @434 +@436 := @435 @74 +@441 := {fs : @59} -> {tys : @60} -> (h : @436) -> (hf : @142) -> @199 @396 +@442 := @433 @22 +@443 := @207 @396 +@446 := {tys : @60} -> (h : @436) -> (hf : @175) -> @443 +@447 := @442 @23 +@450 := (h : @435 @183) -> (hf : @56) -> @443 +@453 := @447 (@188 @434) @53 +@454 := @401 @219 +@455 := @402 @219 +@456 := @64 @455 +@457 := @456 @74 +@462 := {fs : @59} -> {tys : @60} -> (h : @457) -> (hf : @142) -> @226 @396 +@463 := @454 @22 +@464 := @234 @396 +@467 := {tys : @60} -> (h : @457) -> (hf : @175) -> @464 +@468 := @463 @23 +@471 := (h : @456 @183) -> (hf : @56) -> @464 +@474 := @468 (@188 @455) @53 +@481 := fun (__v : @393) => Models.Triage.Level.casesOn.{0} @400 @4 @432 @453 @474 +@482 := @5 @30 +@484 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.__wt_0 @30 +@485 := @21 @18 +@487 := @485 @482 @22 +@488 := Prod.{0, 0} +@490 := @488 @57 @18 +@494 := Prod.mk.{0, 0} @57 @18 @9 +@495 := @494 @482 +@496 := @20 @490 +@497 := @21 @490 +@499 := @497 @495 @496 +@500 := Bool.true +@501 := LexLeanTarget.TargetSyntax.Function +@502 := LexLeanTarget.TargetSyntax.Program.functions +@503 := @502 @0 +@504 := @20 @57 +@505 := LexLeanTarget.TargetSyntax.Ty.unit +@506 := LexLeanTarget.TargetSyntax.Value.unit +@509 := LexLeanTarget.TargetSyntax.Expr.value @505 @506 +@514 := LexLeanTarget.TargetSyntax.Function.mk @504 @23 @505 @509 +@519 := List.getD.{0} @501 @503 @9 @514 +@523 := fun (__e_n : @57) => LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.root @4 @9 +@528 := @7 @66 @79 @88 @68 @28 +@531 := @27 @83 @76 @66 +@533 := @485 @79 @68 +@534 := @531 @533 +@535 := @21 @19 +@537 := @535 @88 @28 +@547 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {v : @18} -> {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @528) -> (hs : @82) -> @534 @537 +@549 := LexLeanPreservation.Rust.wtl_cons @0 +@565 := {c : @25} -> + {A : @26} -> + {v : @18} -> + {t : @19} -> + {vs : @59} -> {ts : @60} -> (h : @11 @79 @88 @68 @28) -> (hs : @113) -> @40 @76 @66 @533 @537 +@566 := @549 @1 +@579 := {A : @26} -> + {v : @18} -> + {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @12 @88 @68 @28) -> (hs : @129) -> @48 @66 @533 @537 +@580 := @566 @2 +@590 := {v : @18} -> + {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @13 @68 @28) -> (hs : @142) -> @54 @533 @537 +@591 := @580 @482 +@592 := @5 @88 +@594 := @13 @592 @28 +@595 := @5 @66 +@596 := @485 @595 +@604 := {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @594) -> (hs : @142) -> @54 (@596 @68) @537 +@605 := @591 @10 +@606 := @5 @68 +@608 := @13 @606 @10 +@609 := @5 @79 +@610 := @485 @609 +@612 := @54 (@610 @68) +@613 := @535 @10 +@614 := @613 @28 +@619 := {vs : @59} -> {ts : @60} -> (h : @608) -> (hs : @142) -> @612 @614 +@620 := @605 @22 +@621 := @5 @28 +@623 := @13 @621 @10 +@625 := @485 @592 @22 +@626 := @54 @625 +@630 := {ts : @60} -> (h : @623) -> (hs : @175) -> @626 @614 +@631 := @620 @23 +@633 := @13 @482 @10 +@635 := @485 @606 @22 +@636 := @54 @635 +@637 := @613 @23 +@640 := (h : @633) -> (hs : @56) -> @636 @637 +@641 := @631 @484 +@643 := @485 @621 @22 +@644 := @54 @643 +@646 := (hs : @56) -> @644 @637 +@647 := @641 @53 +@648 := @54 @487 +@649 := @648 @637 +@650 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.denote +@651 := @650 @30 +@652 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.__fits_0 +@653 := @652 @30 +@655 := Models.Main.respond @30 +@656 := Bool +@658 := @488 @656 @656 +@659 := LexLeanTarget.TargetSyntax.Value.bool +@664 := LexLeanPreservation.encPair @656 @656 @659 @659 +@665 := LexLeanTarget.TargetSyntax.Value.nat +@671 := LexLeanPreservation.encExcept @658 @57 @664 @665 @655 +@673 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.root @30 +@674 := Ne.{1} +@675 := LexLeanPreservation.Obs +@676 := @674 @675 +@677 := LexLeanPreservation.Rel +@680 := @676 (@677 @30 @4) +@681 := LexLeanPreservation.Obs.stuck +@684 := (f : @656) -> (v : @18) -> @680 @681 +@686 := LexLeanPreservation.Rust.rel_ne_stuck @653 +@692 := (v : @18) -> @676 (@677 (@652 @28) @4) @681 +@693 := @686 @671 +@697 := @676 (@677 @653 @671) @681 +@698 := @58 @490 +@699 := LexLeanPreservation.Rust.FunSem +@700 := #9 +@706 := (n : @57) -> @699 @700 @83 @76 @4 @66 +@707 := @62 @501 +@708 := @61 @707 +@715 := LexLeanRuntime.index (@58 @501) @501 (LexLeanRuntime.instIndexableList @501) +@719 := @708 (@715 (@502 @700) @66) +@720 := @72 @501 +@721 := @720 @79 +@722 := @719 @721 +@723 := #10 +@727 := @27 @723 @700 @83 @79 +@728 := LexLeanTarget.TargetSyntax.Function.types +@729 := @728 @66 +@730 := @727 @729 +@731 := @62 @698 +@732 := @61 @731 +@733 := LexLeanTarget.TargetSemantics.bindAll +@734 := LexLeanTarget.TargetSyntax.Function.parameters +@739 := @732 (@733 (@734 @76) @66 @496) +@740 := @72 @698 +@741 := @740 @79 +@742 := @739 @741 +@743 := @62 @656 +@744 := @61 @743 +@745 := LexLeanPreservation.Rust.fnFallible +@746 := #11 +@749 := @744 (@745 @746 @700) +@750 := @72 @656 +@751 := @750 @79 +@752 := @749 @751 +@753 := LexLeanPreservation.RunConv +@754 := #13 +@758 := @753 @754 @723 @83 @79 +@760 := @676 @66 @681 +@761 := Exists.{1} +@762 := LexLeanPreservation.Rust.ROut +@763 := @761 @762 +@764 := And +@765 := LexLeanPreservation.Rust.RealizesFn +@769 := @764 (@765 @700 @83 @4) +@770 := LexLeanPreservation.Rust.RCI +@772 := @770 #15 +@773 := LexLeanPreservation.Rust.fnIdent +@774 := @773 @754 +@781 := (hne : @760) -> @763 (fun (ro : @762) => @769 (@772 @774 @746 @4)) +@796 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {f : @57} -> + {fn : @501} -> + {args : @59} -> + {env : @698} -> + {F : @656} -> + {o : @675} -> + (hB : @706) -> + (hfn : @722) -> (hwt : @730) -> (hbind : @742) -> (hF : @752) -> (hA : @758) -> @781 +@798 := LexLeanPreservation.Rust.compose @0 +@799 := @699 @0 +@804 := (n : @57) -> @799 @83 @76 @4 @66 +@805 := @715 @503 +@808 := @708 (@805 @66) @721 +@812 := @40 @700 @83 @79 @729 +@813 := @753 @0 +@816 := @813 @723 @83 @79 +@830 := {c : @25} -> + {A : @26} -> + {f : @57} -> + {fn : @501} -> + {args : @59} -> + {env : @698} -> + {F : @656} -> + {o : @675} -> + (hB : @804) -> + (hfn : @808) -> (hwt : @812) -> (hbind : @742) -> (hF : @752) -> (hA : @816) -> @781 +@831 := @798 @1 +@832 := @799 @1 +@836 := (n : @57) -> @832 @76 @4 @66 +@839 := @48 @83 @79 @729 +@840 := @745 @1 +@843 := @744 (@840 @700) @751 +@844 := @770 @1 +@854 := (hbind : @742) -> + (hF : @843) -> (hA : @816) -> (hne : @760) -> @763 (fun (ro : @762) => @769 (@844 @774 @746 @4)) +@864 := {A : @26} -> + {f : @57} -> + {fn : @501} -> + {args : @59} -> + {env : @698} -> {F : @656} -> {o : @675} -> (hB : @836) -> (hfn : @808) -> (hwt : @839) -> @854 +@865 := @831 @2 +@867 := @832 @2 @4 +@869 := (n : @57) -> @867 @66 +@870 := @54 @79 +@871 := @870 @729 +@880 := {f : @57} -> + {fn : @501} -> + {args : @59} -> + {env : @698} -> {F : @656} -> {o : @675} -> (hB : @869) -> (hfn : @808) -> (hwt : @871) -> @854 +@881 := @865 @9 +@883 := (n : @57) -> @867 @9 +@884 := @805 @9 +@885 := @708 @884 +@886 := @885 @721 +@887 := @840 @9 +@888 := @744 @887 +@889 := @888 @751 +@890 := @813 @9 +@892 := @890 @83 @79 +@894 := @844 (@773 @9) +@902 := (hF : @889) -> (hA : @892) -> (hne : @760) -> @763 (fun (ro : @762) => @769 (@894 @746 @4)) +@911 := {fn : @501} -> + {args : @59} -> + {env : @698} -> + {F : @656} -> {o : @675} -> (hB : @883) -> (hfn : @886) -> (hwt : @871) -> (hbind : @742) -> @902 +@912 := @881 @519 +@914 := @885 (@720 @519) +@915 := @728 @519 +@916 := @870 @915 +@918 := @733 (@734 @519) +@930 := {args : @59} -> + {env : @698} -> + {F : @656} -> + {o : @675} -> + (hB : @883) -> (hfn : @914) -> (hwt : @916) -> (hbind : @732 (@918 @66 @496) @741) -> @902 +@931 := @912 @487 +@932 := @596 @22 +@934 := @54 @932 @915 +@937 := @485 (@5 @76) @22 +@941 := @732 (@918 @937 @496) @741 +@944 := @485 (@5 @700) @22 +@965 := {env : @698} -> + {F : @656} -> + {o : @675} -> + (hB : @883) -> + (hfn : @914) -> + (hwt : @934) -> + (hbind : @941) -> + (hF : @889) -> + (hA : @890 @944 @79) -> + (hne : @760) -> @763 (fun (ro : @762) => @769 (@894 (@485 (@5 #12) @22) @4)) +@966 := @931 @499 +@967 := @610 @22 +@969 := @54 @967 @915 +@977 := @732 (@918 @932 @496) (@740 (@497 (@494 @595) @496)) +@980 := @485 (@5 @83) @22 +@999 := {F : @656} -> + {o : @675} -> + (hB : @883) -> + (hfn : @914) -> + (hwt : @969) -> + (hbind : @977) -> + (hF : @889) -> + (hA : @890 @980 @79) -> + (hne : @760) -> @763 (fun (ro : @762) => @769 (@894 (@485 (@5 @746) @22) @4)) +@1000 := @966 @500 +@1001 := @626 @915 +@1009 := @732 (@918 @967 @496) (@740 (@497 (@494 @609) @496)) +@1011 := @888 (@750 @500) +@1013 := @890 @937 @79 +@1014 := @765 @500 +@1033 := {o : @675} -> + (hB : @883) -> + (hfn : @914) -> + (hwt : @1001) -> + (hbind : @1009) -> + (hF : @1011) -> + (hA : @1013) -> + (hne : @760) -> @763 (fun (ro : @762) => @764 (@1014 @83 @4) (@894 (@485 (@5 @723) @22) @4)) +@1034 := @1000 @651 +@1035 := @636 @915 +@1043 := @732 (@918 @625 @496) (@740 (@497 (@494 @592) @496)) +@1044 := @890 @932 +@1045 := @650 @66 +@1046 := @1044 @1045 +@1047 := @650 @76 +@1065 := (hB : @883) -> + (hfn : @914) -> + (hwt : @1035) -> + (hbind : @1043) -> + (hF : @1011) -> + (hA : @1046) -> + (hne : @676 @1047 @681) -> @763 (fun (ro : @762) => @764 (@1014 (@650 @700) @4) (@894 @944 @4)) +@1066 := @1034 @523 +@1067 := @644 @915 +@1075 := @732 (@918 @635 @496) (@740 (@497 (@494 @606) @496)) +@1076 := @890 @967 +@1077 := @650 @79 +@1095 := (hfn : @914) -> + (hwt : @1067) -> + (hbind : @1075) -> + (hF : @1011) -> + (hA : @1076 @1077) -> + (hne : @676 @1045 @681) -> @763 (fun (ro : @762) => @764 (@1014 (@650 @83) @4) (@894 @980 @4)) +@1098 := @1066 (@187 @707 @884) +@1099 := @648 @915 +@1107 := @732 (@918 @643 @496) (@740 (@497 (@494 @621) @496)) +@1108 := @890 @625 +@1109 := @650 @88 +@1125 := (hwt : @1099) -> + (hbind : @1107) -> + (hF : @1011) -> + (hA : @1108 @1109) -> + (hne : @676 @1077 @681) -> @763 (fun (ro : @762) => @764 (@1014 @1047 @4) (@894 @937 @4)) +@1126 := @1098 @647 +@1128 := @918 @487 @496 +@1131 := @732 @1128 (@740 @499) +@1132 := @890 @635 +@1133 := @650 @68 +@1148 := (hbind : @1131) -> + (hF : @1011) -> + (hA : @1132 @1133) -> + (hne : @676 @1109 @681) -> @763 (fun (ro : @762) => @764 (@1014 @1045 @4) (@894 @932 @4)) +@1151 := @1126 (@187 @731 @1128) +@1152 := @890 @643 +@1153 := @650 @28 +@1167 := (hF : @1011) -> + (hA : @1152 @1153) -> + (hne : @676 @1133 @681) -> @763 (fun (ro : @762) => @764 (@1014 @1077 @4) (@894 @967 @4)) +@1170 := @1151 (@187 @743 @887) +@1184 := (hA : @890 @487 @651) -> + (hne : @676 @1153 @681) -> @763 (fun (ro : @762) => @764 (@1014 @1109 @4) (@894 @625 @4)) +@1185 := @1170 @673 +@1196 := (hne : @676 @651 @681) -> @763 (fun (ro : @762) => @764 (@1014 @1133 @4) (@894 @635 @4)) +@1197 := @1185 @693 +@1203 := @764 (@1014 @1153 @4) (@894 @643 @4) +@1205 := @763 (fun (ro : @762) => @1203) +@1207 := @763 (fun (__e_ro : @762) => @1203) +@1211 := LexLeanPreservation.Rust.RepresentableL (@485 @6 @22) +@1212 := (__e_hrep : @1211) -> @1207 +@1213 := fun (__e_hrep : @1211) => @1197 +@1214 := (presentation : @3) -> @1212 +@1215 := fun (presentation : @3) => @1213 +\end{coremodule} +\end{lexlean} diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R3/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R3/Compose/RustStd.lean deleted file mode 100644 index fbf22bf27..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R3/Compose/RustStd.lean +++ /dev/null @@ -1,19 +0,0 @@ -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3 -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd - -theorem __wt_0 : ∀ (__s : (Models.Session.Window)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.program _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.krate _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.flags (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.__enc_0 __s) (.adt 0) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).used) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).items) _root_.LexLeanPreservation.Rust.wtl_nil)) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (costs : (List Nat)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) costs)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.denote costs) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) costs)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat) costs) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.root costs) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R3/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R3/Compose/RustStd.lex.tex new file mode 100644 index 000000000..6a02be742 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R3/Compose/RustStd.lex.tex @@ -0,0 +1,600 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3, + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd.root : @1207 := @1208 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.program +@1 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.krate +@2 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.flags +@3 := Models.Session.Window +@4 := #0 +@6 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.__enc_0 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@16 := (__s : @3) -> @13 @6 @10 +@17 := Models.Session.Window.used +@18 := @17 @4 +@19 := Models.Session.Window.items +@20 := @19 @4 +@21 := LexLeanTarget.TargetSyntax.Value.nat +@22 := @21 @18 +@23 := LexLeanTarget.TargetSyntax.Ty.nat +@24 := LexLeanTarget.TargetSyntax.Program +@25 := LexLeanPreservation.Rust.RCrate +@26 := LexLeanPreservation.Rust.Flags +@27 := Nat +@28 := #3 +@29 := @7 @28 +@30 := #2 +@31 := @29 @30 +@32 := #1 +@33 := @31 @32 +@34 := @21 @4 +@40 := {p : @24} -> {c : @25} -> {A : @26} -> (n : @27) -> @33 @34 @23 +@42 := LexLeanPreservation.Rust.wt_nat @0 +@49 := {c : @25} -> {A : @26} -> (n : @27) -> @11 @30 @32 @34 @23 +@50 := @42 @1 +@55 := {A : @26} -> (n : @27) -> @12 @32 @34 @23 +@56 := @50 @2 +@57 := @13 @34 +@58 := @57 @23 +@59 := (n : @27) -> @58 +@60 := @56 @18 +@62 := @13 @22 @23 +@63 := @21 @20 +@64 := @56 @20 +@66 := @13 @63 @23 +@67 := LexLeanTarget.TargetSyntax.Value +@68 := LexLeanTarget.TargetSyntax.Ty +@69 := List.nil.{0} +@70 := List.cons.{0} +@71 := @69 @67 +@72 := @70 @67 +@74 := @72 @63 @71 +@76 := @72 @22 @74 +@77 := @69 @68 +@78 := @70 @68 +@79 := @78 @23 +@80 := @79 @77 +@81 := @79 @80 +@82 := LexLeanPreservation.Rust.WTL +@90 := {p : @24} -> {c : @25} -> {A : @26} -> @82 @30 @32 @4 @71 @77 +@92 := LexLeanPreservation.Rust.wtl_nil @0 +@93 := @82 @0 +@99 := {c : @25} -> {A : @26} -> @93 @32 @4 @71 @77 +@100 := @92 @1 +@101 := @93 @1 +@105 := {A : @26} -> @101 @4 @71 @77 +@106 := @100 @2 +@107 := @101 @2 +@108 := @107 @71 +@109 := @108 @77 +@110 := List.{0} +@111 := @110 @67 +@112 := @110 @68 +@113 := #6 +@114 := @7 @113 +@115 := #5 +@116 := @114 @115 +@117 := #4 +@118 := @116 @117 +@120 := @118 @28 @30 +@121 := #7 +@126 := @82 @121 @113 @115 @30 @32 +@127 := #8 +@130 := @82 @127 @121 @113 +@132 := @72 @115 @28 +@133 := @130 @132 +@135 := @78 @117 @30 +@145 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {v : @67} -> {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @120) -> (hs : @126) -> @133 @135 +@147 := LexLeanPreservation.Rust.wtl_cons @0 +@149 := @11 @115 @117 +@151 := @149 @28 @30 +@155 := @93 @113 @115 @30 @32 +@167 := {c : @25} -> + {A : @26} -> + {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @151) -> (hs : @155) -> @93 @121 @113 @132 @135 +@168 := @147 @1 +@169 := @12 @117 +@171 := @169 @28 @30 +@174 := @101 @115 @30 @32 +@184 := {A : @26} -> + {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @171) -> (hs : @174) -> @101 @113 @132 @135 +@185 := @168 @2 +@187 := @13 @28 @30 +@189 := @107 @30 @32 +@197 := {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @187) -> (hs : @189) -> @107 @132 @135 +@198 := @185 @63 +@200 := @21 (@19 @28) +@213 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @200 @30) -> (hs : @189) -> @107 (@72 (@21 (@19 @115)) @28) @135 +@214 := @198 @23 +@216 := @21 (@19 @30) +@218 := @13 @216 @23 +@223 := @107 (@72 (@21 (@19 @117)) @28) +@224 := @79 @30 +@229 := {vs : @111} -> {ts : @112} -> (h : @218) -> (hs : @189) -> @223 @224 +@230 := @214 @71 +@232 := @21 (@19 @32) +@234 := @13 @232 @23 +@235 := @108 @32 +@237 := @72 @200 @71 +@242 := {ts : @112} -> (h : @234) -> (hs : @235) -> @107 @237 @224 +@243 := @230 @77 +@245 := @72 @216 @71 +@246 := @107 @245 +@249 := (h : @66) -> (hs : @109) -> @246 @80 +@250 := @243 @64 +@252 := @72 @232 @71 +@254 := @107 @252 @80 +@255 := (hs : @109) -> @254 +@256 := @250 @106 +@258 := @107 @74 @80 +@259 := @185 @22 +@261 := @21 (@17 @28) +@274 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @261 @30) -> (hs : @189) -> @107 (@72 (@21 (@17 @115)) @28) @135 +@275 := @259 @23 +@277 := @21 (@17 @30) +@289 := {vs : @111} -> + {ts : @112} -> (h : @13 @277 @23) -> (hs : @189) -> @107 (@72 (@21 (@17 @117)) @28) @224 +@290 := @275 @74 +@292 := @21 (@17 @32) +@294 := @13 @292 @23 +@295 := @246 @32 +@297 := @72 @261 @237 +@302 := {ts : @112} -> (h : @294) -> (hs : @295) -> @107 @297 @224 +@303 := @290 @80 +@305 := @72 @277 @245 +@306 := @107 @305 +@309 := (h : @62) -> (hs : @254) -> @306 @81 +@310 := @303 @60 +@312 := @72 @292 @252 +@314 := @107 @312 @81 +@315 := (hs : @258) -> @314 +@316 := @310 @256 +@318 := @107 @76 @81 +@319 := Eq.{1} +@320 := Option.{0} +@321 := @320 @112 +@322 := @319 @321 +@323 := LexLeanPreservation.Rust.adtFields +@327 := @322 (@323 @113 @28 @30) +@328 := Option.some.{0} +@329 := @328 @112 +@330 := @329 @4 +@331 := @327 @330 +@334 := @7 @127 @121 @113 +@335 := LexLeanTarget.TargetSyntax.Value.adt +@337 := @335 @117 @28 +@338 := @334 @337 +@339 := @8 @115 +@349 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {i : @27} -> {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @331) -> (hf : @126) -> @338 @339 +@351 := LexLeanPreservation.Rust.wt_adt @0 +@352 := @323 @0 +@356 := @322 (@352 @28 @30) @330 +@368 := {c : @25} -> + {A : @26} -> + {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @155) -> @11 @121 @113 @337 @339 +@369 := @351 @1 +@379 := {A : @26} -> + {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @174) -> @12 @113 @337 @339 +@380 := @369 @2 +@381 := @13 @337 +@388 := {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @189) -> @381 @339 +@389 := @380 @9 +@390 := @352 @9 +@399 := {k : @27} -> + {fs : @111} -> {tys : @112} -> (h : @322 (@390 @30) @330) -> (hf : @189) -> @381 @10 +@400 := @389 @9 +@401 := @390 @9 +@402 := @322 @401 +@403 := @402 @330 +@404 := @335 @9 +@411 := {fs : @111} -> {tys : @112} -> (h : @403) -> (hf : @189) -> @13 (@404 @28) @10 +@412 := @400 @76 +@419 := {tys : @112} -> (h : @403) -> (hf : @306 @32) -> @13 (@404 @297) @10 +@420 := @412 @81 +@427 := (h : @402 (@329 @81)) -> (hf : @314) -> @13 (@404 @305) @10 +@428 := Eq.refl.{1} +@431 := @420 (@428 @321 @401) +@435 := (hf : @318) -> @13 (@404 @312) @10 +@436 := @431 @316 +@439 := @13 (@404 @76) @10 +@440 := fun (__s : @3) => @436 +@441 := @110 @27 +@442 := LexLeanPreservation.encList +@443 := @442 @27 +@444 := @443 @21 +@445 := @444 @32 +@446 := LexLeanTarget.TargetSyntax.Ty.list +@447 := @446 @23 +@449 := fun (__x : @27) => @56 @4 +@450 := Sort 1 +@451 := (a._@._internal._hyg.#0 : @4) -> @67 +@452 := @30 @4 +@455 := (x : @30) -> @118 @452 @32 +@456 := @110 @28 +@459 := @7 @121 @113 @115 +@462 := @442 @117 @28 @4 +@463 := @459 @462 +@464 := @446 @30 +@473 := {p : @24} -> + {c : @25} -> + {A : @26} -> {α : @450} -> {e : @451} -> {t : @68} -> (h : @455) -> (xs : @456) -> @463 @464 +@475 := LexLeanPreservation.Rust.wt_encList @0 +@489 := {c : @25} -> + {A : @26} -> + {α : @450} -> + {e : @451} -> + {t : @68} -> (h : (x : @30) -> @149 @452 @32) -> (xs : @456) -> @11 @113 @115 @462 @464 +@490 := @475 @1 +@502 := {A : @26} -> + {α : @450} -> + {e : @451} -> {t : @68} -> (h : (x : @30) -> @169 @452 @32) -> (xs : @456) -> @12 @115 @462 @464 +@503 := @490 @2 +@505 := @13 @452 @32 +@513 := {α : @450} -> + {e : @451} -> {t : @68} -> (h : (x : @30) -> @505) -> (xs : @456) -> @13 @462 @464 +@514 := @503 @27 +@524 := {e : (a._@._internal._hyg.#0 : @27) -> @67} -> + {t : @68} -> (h : (x : @27) -> @505) -> (xs : @441) -> @13 (@443 @28 @4) @464 +@525 := @514 @21 +@527 := (x : @27) -> @57 @32 +@528 := @444 @4 +@529 := @13 @528 +@533 := {t : @68} -> (h : @527) -> (xs : @441) -> @529 @464 +@534 := @525 @23 +@538 := (h : (x : @27) -> @58) -> (xs : @441) -> @529 @447 +@540 := @534 @449 @32 +@542 := @13 @445 @447 +@544 := @72 @445 @71 +@545 := Prod.{0, 0} +@547 := @545 @27 @67 +@551 := Prod.mk.{0, 0} @27 @67 @9 +@552 := @551 @445 +@553 := @69 @547 +@554 := @70 @547 +@556 := @554 @552 @553 +@557 := Bool.true +@558 := LexLeanTarget.TargetSyntax.Function +@559 := LexLeanTarget.TargetSyntax.Program.functions +@560 := @559 @0 +@561 := @69 @27 +@562 := LexLeanTarget.TargetSyntax.Ty.unit +@563 := LexLeanTarget.TargetSyntax.Value.unit +@566 := LexLeanTarget.TargetSyntax.Expr.value @562 @563 +@571 := LexLeanTarget.TargetSyntax.Function.mk @561 @77 @562 @566 +@576 := List.getD.{0} @558 @560 @9 @571 +@580 := fun (__e_n : @27) => LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.root @4 @9 +@581 := @185 @445 +@582 := @444 @117 +@584 := @13 @582 @30 +@585 := @444 @113 +@586 := @72 @585 +@594 := {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @584) -> (hs : @189) -> @107 (@586 @28) @135 +@595 := @581 @447 +@596 := @444 @28 +@598 := @13 @596 @447 +@599 := @444 @115 +@600 := @72 @599 +@602 := @107 (@600 @28) +@603 := @78 @447 +@604 := @603 @30 +@609 := {vs : @111} -> {ts : @112} -> (h : @598) -> (hs : @189) -> @602 @604 +@610 := @595 @71 +@611 := @444 @30 +@613 := @13 @611 @447 +@615 := @72 @582 @71 +@616 := @107 @615 +@620 := {ts : @112} -> (h : @613) -> (hs : @235) -> @616 @604 +@621 := @610 @77 +@623 := @72 @596 @71 +@624 := @107 @623 +@625 := @603 @77 +@628 := (h : @542) -> (hs : @109) -> @624 @625 +@629 := @621 @540 +@631 := @72 @611 @71 +@632 := @107 @631 +@634 := (hs : @109) -> @632 @625 +@635 := @629 @106 +@636 := @107 @544 +@637 := @636 @625 +@638 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.denote +@639 := @638 @32 +@640 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.__fits_0 +@641 := @640 @32 +@643 := Models.Main.admitCosts @32 +@644 := Bool +@646 := @545 @644 @644 +@649 := Except.{0, 0} @646 @441 +@650 := LexLeanTarget.TargetSyntax.Value.bool +@655 := LexLeanPreservation.encPair @644 @644 @650 @650 +@657 := LexLeanPreservation.encExcept @646 +@660 := @657 @441 @655 @444 +@664 := @657 @649 @655 @660 @643 +@666 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.root @32 +@667 := Ne.{1} +@668 := LexLeanPreservation.Obs +@669 := @667 @668 +@670 := LexLeanPreservation.Rel +@673 := @669 (@670 @32 @4) +@674 := LexLeanPreservation.Obs.stuck +@677 := (f : @644) -> (v : @67) -> @673 @674 +@679 := LexLeanPreservation.Rust.rel_ne_stuck @641 +@685 := (v : @67) -> @669 (@670 (@640 @30) @4) @674 +@686 := @679 @664 +@690 := @669 (@670 @641 @664) @674 +@691 := @110 @547 +@692 := LexLeanPreservation.Rust.FunSem +@693 := #9 +@699 := (n : @27) -> @692 @693 @127 @121 @4 @113 +@700 := @320 @558 +@701 := @319 @700 +@708 := LexLeanRuntime.index (@110 @558) @558 (LexLeanRuntime.instIndexableList @558) +@712 := @701 (@708 (@559 @693) @113) +@713 := @328 @558 +@714 := @713 @115 +@715 := @712 @714 +@716 := #10 +@720 := @82 @716 @693 @127 @115 +@721 := LexLeanTarget.TargetSyntax.Function.types +@722 := @721 @113 +@723 := @720 @722 +@724 := @320 @691 +@725 := @319 @724 +@726 := LexLeanTarget.TargetSemantics.bindAll +@727 := LexLeanTarget.TargetSyntax.Function.parameters +@732 := @725 (@726 (@727 @121) @113 @553) +@733 := @328 @691 +@734 := @733 @115 +@735 := @732 @734 +@736 := @320 @644 +@737 := @319 @736 +@738 := LexLeanPreservation.Rust.fnFallible +@739 := #11 +@742 := @737 (@738 @739 @693) +@743 := @328 @644 +@744 := @743 @115 +@745 := @742 @744 +@746 := LexLeanPreservation.RunConv +@747 := #13 +@751 := @746 @747 @716 @127 @115 +@753 := @669 @113 @674 +@754 := Exists.{1} +@755 := LexLeanPreservation.Rust.ROut +@756 := @754 @755 +@757 := And +@758 := LexLeanPreservation.Rust.RealizesFn +@762 := @757 (@758 @693 @127 @4) +@763 := LexLeanPreservation.Rust.RCI +@765 := @763 #15 +@766 := LexLeanPreservation.Rust.fnIdent +@767 := @766 @747 +@774 := (hne : @753) -> @756 (fun (ro : @755) => @762 (@765 @767 @739 @4)) +@789 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {f : @27} -> + {fn : @558} -> + {args : @111} -> + {env : @691} -> + {F : @644} -> + {o : @668} -> + (hB : @699) -> + (hfn : @715) -> (hwt : @723) -> (hbind : @735) -> (hF : @745) -> (hA : @751) -> @774 +@791 := LexLeanPreservation.Rust.compose @0 +@792 := @692 @0 +@797 := (n : @27) -> @792 @127 @121 @4 @113 +@798 := @708 @560 +@801 := @701 (@798 @113) @714 +@805 := @93 @693 @127 @115 @722 +@806 := @746 @0 +@809 := @806 @716 @127 @115 +@823 := {c : @25} -> + {A : @26} -> + {f : @27} -> + {fn : @558} -> + {args : @111} -> + {env : @691} -> + {F : @644} -> + {o : @668} -> + (hB : @797) -> + (hfn : @801) -> (hwt : @805) -> (hbind : @735) -> (hF : @745) -> (hA : @809) -> @774 +@824 := @791 @1 +@825 := @792 @1 +@829 := (n : @27) -> @825 @121 @4 @113 +@832 := @101 @127 @115 @722 +@833 := @738 @1 +@836 := @737 (@833 @693) @744 +@837 := @763 @1 +@847 := (hbind : @735) -> + (hF : @836) -> (hA : @809) -> (hne : @753) -> @756 (fun (ro : @755) => @762 (@837 @767 @739 @4)) +@857 := {A : @26} -> + {f : @27} -> + {fn : @558} -> + {args : @111} -> + {env : @691} -> {F : @644} -> {o : @668} -> (hB : @829) -> (hfn : @801) -> (hwt : @832) -> @847 +@858 := @824 @2 +@860 := @825 @2 @4 +@862 := (n : @27) -> @860 @113 +@863 := @107 @115 +@864 := @863 @722 +@873 := {f : @27} -> + {fn : @558} -> + {args : @111} -> + {env : @691} -> {F : @644} -> {o : @668} -> (hB : @862) -> (hfn : @801) -> (hwt : @864) -> @847 +@874 := @858 @9 +@876 := (n : @27) -> @860 @9 +@877 := @798 @9 +@878 := @701 @877 +@879 := @878 @714 +@880 := @833 @9 +@881 := @737 @880 +@882 := @881 @744 +@883 := @806 @9 +@885 := @883 @127 @115 +@887 := @837 (@766 @9) +@895 := (hF : @882) -> (hA : @885) -> (hne : @753) -> @756 (fun (ro : @755) => @762 (@887 @739 @4)) +@904 := {fn : @558} -> + {args : @111} -> + {env : @691} -> + {F : @644} -> {o : @668} -> (hB : @876) -> (hfn : @879) -> (hwt : @864) -> (hbind : @735) -> @895 +@905 := @874 @576 +@907 := @878 (@713 @576) +@908 := @721 @576 +@909 := @863 @908 +@911 := @726 (@727 @576) +@923 := {args : @111} -> + {env : @691} -> + {F : @644} -> + {o : @668} -> + (hB : @876) -> (hfn : @907) -> (hwt : @909) -> (hbind : @725 (@911 @113 @553) @734) -> @895 +@924 := @905 @544 +@925 := @586 @71 +@927 := @107 @925 @908 +@930 := @72 (@444 @121) @71 +@934 := @725 (@911 @930 @553) @734 +@937 := @72 (@444 @693) @71 +@958 := {env : @691} -> + {F : @644} -> + {o : @668} -> + (hB : @876) -> + (hfn : @907) -> + (hwt : @927) -> + (hbind : @934) -> + (hF : @882) -> + (hA : @883 @937 @115) -> + (hne : @753) -> @756 (fun (ro : @755) => @762 (@887 (@72 (@444 #12) @71) @4)) +@959 := @924 @556 +@960 := @600 @71 +@962 := @107 @960 @908 +@970 := @725 (@911 @925 @553) (@733 (@554 (@551 @585) @553)) +@973 := @72 (@444 @127) @71 +@992 := {F : @644} -> + {o : @668} -> + (hB : @876) -> + (hfn : @907) -> + (hwt : @962) -> + (hbind : @970) -> + (hF : @882) -> + (hA : @883 @973 @115) -> + (hne : @753) -> @756 (fun (ro : @755) => @762 (@887 (@72 (@444 @739) @71) @4)) +@993 := @959 @557 +@994 := @616 @908 +@1002 := @725 (@911 @960 @553) (@733 (@554 (@551 @599) @553)) +@1004 := @881 (@743 @557) +@1006 := @883 @930 @115 +@1007 := @758 @557 +@1026 := {o : @668} -> + (hB : @876) -> + (hfn : @907) -> + (hwt : @994) -> + (hbind : @1002) -> + (hF : @1004) -> + (hA : @1006) -> + (hne : @753) -> @756 (fun (ro : @755) => @757 (@1007 @127 @4) (@887 (@72 (@444 @716) @71) @4)) +@1027 := @993 @639 +@1028 := @624 @908 +@1036 := @725 (@911 @615 @553) (@733 (@554 (@551 @582) @553)) +@1037 := @883 @925 +@1038 := @638 @113 +@1039 := @1037 @1038 +@1040 := @638 @121 +@1058 := (hB : @876) -> + (hfn : @907) -> + (hwt : @1028) -> + (hbind : @1036) -> + (hF : @1004) -> + (hA : @1039) -> + (hne : @669 @1040 @674) -> @756 (fun (ro : @755) => @757 (@1007 (@638 @693) @4) (@887 @937 @4)) +@1059 := @1027 @580 +@1060 := @632 @908 +@1068 := @725 (@911 @623 @553) (@733 (@554 (@551 @596) @553)) +@1069 := @883 @960 +@1070 := @638 @115 +@1088 := (hfn : @907) -> + (hwt : @1060) -> + (hbind : @1068) -> + (hF : @1004) -> + (hA : @1069 @1070) -> + (hne : @669 @1038 @674) -> @756 (fun (ro : @755) => @757 (@1007 (@638 @127) @4) (@887 @973 @4)) +@1091 := @1059 (@428 @700 @877) +@1092 := @636 @908 +@1100 := @725 (@911 @631 @553) (@733 (@554 (@551 @611) @553)) +@1101 := @883 @615 +@1102 := @638 @117 +@1118 := (hwt : @1092) -> + (hbind : @1100) -> + (hF : @1004) -> + (hA : @1101 @1102) -> + (hne : @669 @1070 @674) -> @756 (fun (ro : @755) => @757 (@1007 @1040 @4) (@887 @930 @4)) +@1119 := @1091 @635 +@1121 := @911 @544 @553 +@1124 := @725 @1121 (@733 @556) +@1125 := @883 @623 +@1126 := @638 @28 +@1141 := (hbind : @1124) -> + (hF : @1004) -> + (hA : @1125 @1126) -> + (hne : @669 @1102 @674) -> @756 (fun (ro : @755) => @757 (@1007 @1038 @4) (@887 @925 @4)) +@1144 := @1119 (@428 @724 @1121) +@1145 := @883 @631 +@1146 := @638 @30 +@1160 := (hF : @1004) -> + (hA : @1145 @1146) -> + (hne : @669 @1126 @674) -> @756 (fun (ro : @755) => @757 (@1007 @1070 @4) (@887 @960 @4)) +@1163 := @1144 (@428 @736 @880) +@1177 := (hA : @883 @544 @639) -> + (hne : @669 @1146 @674) -> @756 (fun (ro : @755) => @757 (@1007 @1102 @4) (@887 @615 @4)) +@1178 := @1163 @666 +@1189 := (hne : @669 @639 @674) -> @756 (fun (ro : @755) => @757 (@1007 @1126 @4) (@887 @623 @4)) +@1190 := @1178 @686 +@1196 := @757 (@1007 @1146 @4) (@887 @631 @4) +@1198 := @756 (fun (ro : @755) => @1196) +@1200 := @756 (fun (__e_ro : @755) => @1196) +@1204 := LexLeanPreservation.Rust.RepresentableL (@72 @528 @71) +@1205 := (__e_hrep : @1204) -> @1200 +@1206 := fun (__e_hrep : @1204) => @1190 +@1207 := (costs : @441) -> @1205 +@1208 := fun (costs : @441) => @1206 +\end{coremodule} +\end{lexlean} diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R4/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R4/Compose/RustStd.lean deleted file mode 100644 index 0b9843349..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R4/Compose/RustStd.lean +++ /dev/null @@ -1,19 +0,0 @@ -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4 -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd - -theorem __wt_0 : ∀ (__s : (Models.Session.Window)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.program _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.krate _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.flags (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.__enc_0 __s) (.adt 0) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).used) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).items) _root_.LexLeanPreservation.Rust.wtl_nil)) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (window : (Models.Session.Window)) (cost : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.__enc_0 window), (_root_.LexLeanTarget.TargetSyntax.Value.nat cost)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.denote window cost) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.__enc_0 window), (_root_.LexLeanTarget.TargetSyntax.Value.nat cost)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 window) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat cost) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.root window cost) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R4/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R4/Compose/RustStd.lex.tex new file mode 100644 index 000000000..6184b5a9f --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R4/Compose/RustStd.lex.tex @@ -0,0 +1,601 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4, + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.root : @1229 := @1230 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.program +@1 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.krate +@2 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.flags +@3 := Models.Session.Window +@4 := #0 +@5 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@16 := (__s : @3) -> @13 @6 @10 +@17 := Models.Session.Window.used +@18 := @17 @4 +@19 := Models.Session.Window.items +@20 := @19 @4 +@21 := LexLeanTarget.TargetSyntax.Value.nat +@22 := @21 @18 +@23 := LexLeanTarget.TargetSyntax.Ty.nat +@24 := LexLeanTarget.TargetSyntax.Program +@25 := LexLeanPreservation.Rust.RCrate +@26 := LexLeanPreservation.Rust.Flags +@27 := Nat +@28 := #3 +@29 := @7 @28 +@30 := #2 +@31 := @29 @30 +@32 := #1 +@33 := @31 @32 +@34 := @21 @4 +@40 := {p : @24} -> {c : @25} -> {A : @26} -> (n : @27) -> @33 @34 @23 +@42 := LexLeanPreservation.Rust.wt_nat @0 +@49 := {c : @25} -> {A : @26} -> (n : @27) -> @11 @30 @32 @34 @23 +@50 := @42 @1 +@55 := {A : @26} -> (n : @27) -> @12 @32 @34 @23 +@56 := @50 @2 +@59 := (n : @27) -> @13 @34 @23 +@60 := @56 @18 +@62 := @13 @22 @23 +@63 := @21 @20 +@64 := @56 @20 +@66 := @13 @63 @23 +@67 := LexLeanTarget.TargetSyntax.Value +@68 := LexLeanTarget.TargetSyntax.Ty +@69 := List.nil.{0} +@70 := List.cons.{0} +@71 := @69 @67 +@72 := @70 @67 +@74 := @72 @63 @71 +@76 := @72 @22 @74 +@77 := @69 @68 +@78 := @70 @68 +@79 := @78 @23 +@80 := @79 @77 +@81 := @79 @80 +@82 := LexLeanPreservation.Rust.WTL +@90 := {p : @24} -> {c : @25} -> {A : @26} -> @82 @30 @32 @4 @71 @77 +@92 := LexLeanPreservation.Rust.wtl_nil @0 +@93 := @82 @0 +@99 := {c : @25} -> {A : @26} -> @93 @32 @4 @71 @77 +@100 := @92 @1 +@101 := @93 @1 +@105 := {A : @26} -> @101 @4 @71 @77 +@106 := @100 @2 +@107 := @101 @2 +@108 := @107 @71 +@109 := @108 @77 +@110 := List.{0} +@111 := @110 @67 +@112 := @110 @68 +@113 := #6 +@114 := @7 @113 +@115 := #5 +@116 := @114 @115 +@117 := #4 +@120 := @116 @117 @28 @30 +@121 := #7 +@126 := @82 @121 @113 @115 @30 @32 +@127 := #8 +@130 := @82 @127 @121 @113 +@132 := @72 @115 @28 +@133 := @130 @132 +@135 := @78 @117 @30 +@145 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {v : @67} -> {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @120) -> (hs : @126) -> @133 @135 +@147 := LexLeanPreservation.Rust.wtl_cons @0 +@151 := @11 @115 @117 @28 @30 +@155 := @93 @113 @115 @30 @32 +@167 := {c : @25} -> + {A : @26} -> + {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @151) -> (hs : @155) -> @93 @121 @113 @132 @135 +@168 := @147 @1 +@171 := @12 @117 @28 @30 +@174 := @101 @115 @30 @32 +@184 := {A : @26} -> + {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @171) -> (hs : @174) -> @101 @113 @132 @135 +@185 := @168 @2 +@187 := @13 @28 @30 +@189 := @107 @30 @32 +@197 := {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @187) -> (hs : @189) -> @107 @132 @135 +@198 := @185 @63 +@200 := @21 (@19 @28) +@213 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @200 @30) -> (hs : @189) -> @107 (@72 (@21 (@19 @115)) @28) @135 +@214 := @198 @23 +@216 := @21 (@19 @30) +@218 := @13 @216 @23 +@223 := @107 (@72 (@21 (@19 @117)) @28) +@224 := @79 @30 +@229 := {vs : @111} -> {ts : @112} -> (h : @218) -> (hs : @189) -> @223 @224 +@230 := @214 @71 +@232 := @21 (@19 @32) +@234 := @13 @232 @23 +@235 := @108 @32 +@237 := @72 @200 @71 +@242 := {ts : @112} -> (h : @234) -> (hs : @235) -> @107 @237 @224 +@243 := @230 @77 +@245 := @72 @216 @71 +@246 := @107 @245 +@249 := (h : @66) -> (hs : @109) -> @246 @80 +@250 := @243 @64 +@252 := @72 @232 @71 +@254 := @107 @252 @80 +@255 := (hs : @109) -> @254 +@256 := @250 @106 +@258 := @107 @74 @80 +@259 := @185 @22 +@261 := @21 (@17 @28) +@274 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @261 @30) -> (hs : @189) -> @107 (@72 (@21 (@17 @115)) @28) @135 +@275 := @259 @23 +@277 := @21 (@17 @30) +@289 := {vs : @111} -> + {ts : @112} -> (h : @13 @277 @23) -> (hs : @189) -> @107 (@72 (@21 (@17 @117)) @28) @224 +@290 := @275 @74 +@292 := @21 (@17 @32) +@294 := @13 @292 @23 +@295 := @246 @32 +@297 := @72 @261 @237 +@302 := {ts : @112} -> (h : @294) -> (hs : @295) -> @107 @297 @224 +@303 := @290 @80 +@305 := @72 @277 @245 +@306 := @107 @305 +@309 := (h : @62) -> (hs : @254) -> @306 @81 +@310 := @303 @60 +@312 := @72 @292 @252 +@314 := @107 @312 @81 +@315 := (hs : @258) -> @314 +@316 := @310 @256 +@318 := @107 @76 @81 +@319 := Eq.{1} +@320 := Option.{0} +@321 := @320 @112 +@322 := @319 @321 +@323 := LexLeanPreservation.Rust.adtFields +@327 := @322 (@323 @113 @28 @30) +@328 := Option.some.{0} +@329 := @328 @112 +@330 := @329 @4 +@331 := @327 @330 +@334 := @7 @127 @121 @113 +@335 := LexLeanTarget.TargetSyntax.Value.adt +@337 := @335 @117 @28 +@338 := @334 @337 +@339 := @8 @115 +@349 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {i : @27} -> {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @331) -> (hf : @126) -> @338 @339 +@351 := LexLeanPreservation.Rust.wt_adt @0 +@352 := @323 @0 +@356 := @322 (@352 @28 @30) @330 +@368 := {c : @25} -> + {A : @26} -> + {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @155) -> @11 @121 @113 @337 @339 +@369 := @351 @1 +@379 := {A : @26} -> + {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @174) -> @12 @113 @337 @339 +@380 := @369 @2 +@381 := @13 @337 +@388 := {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @189) -> @381 @339 +@389 := @380 @9 +@390 := @352 @9 +@399 := {k : @27} -> + {fs : @111} -> {tys : @112} -> (h : @322 (@390 @30) @330) -> (hf : @189) -> @381 @10 +@400 := @389 @9 +@401 := @390 @9 +@402 := @322 @401 +@403 := @402 @330 +@404 := @335 @9 +@411 := {fs : @111} -> {tys : @112} -> (h : @403) -> (hf : @189) -> @13 (@404 @28) @10 +@412 := @400 @76 +@419 := {tys : @112} -> (h : @403) -> (hf : @306 @32) -> @13 (@404 @297) @10 +@420 := @412 @81 +@427 := (h : @402 (@329 @81)) -> (hf : @314) -> @13 (@404 @305) @10 +@428 := Eq.refl.{1} +@431 := @420 (@428 @321 @401) +@435 := (hf : @318) -> @13 (@404 @312) @10 +@436 := @431 @316 +@439 := @13 (@404 @76) @10 +@440 := fun (__s : @3) => @436 +@441 := @5 @30 +@443 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.__wt_0 @30 +@444 := @21 @32 +@445 := @56 @32 +@447 := @13 @444 @23 +@449 := @72 @444 @71 +@451 := @72 @441 @449 +@452 := Prod.{0, 0} +@454 := @452 @27 @67 +@455 := 1 +@458 := Prod.mk.{0, 0} @27 @67 +@459 := @458 @455 +@460 := @459 @444 +@461 := @458 @9 +@462 := @461 @441 +@463 := @69 @454 +@464 := @70 @454 +@466 := @464 @462 @463 +@468 := @464 @460 @466 +@469 := Bool.true +@470 := LexLeanTarget.TargetSyntax.Function +@471 := LexLeanTarget.TargetSyntax.Program.functions +@472 := @471 @0 +@473 := @69 @27 +@474 := LexLeanTarget.TargetSyntax.Ty.unit +@475 := LexLeanTarget.TargetSyntax.Value.unit +@478 := LexLeanTarget.TargetSyntax.Expr.value @474 @475 +@483 := LexLeanTarget.TargetSyntax.Function.mk @473 @77 @474 @478 +@488 := List.getD.{0} @470 @472 @9 @483 +@492 := fun (__e_n : @27) => LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.root @4 @9 +@493 := @185 @444 +@494 := @21 @117 +@496 := @13 @494 @30 +@497 := @21 @113 +@498 := @72 @497 +@506 := {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @496) -> (hs : @189) -> @107 (@498 @28) @135 +@507 := @493 @23 +@508 := @21 @28 +@510 := @13 @508 @23 +@511 := @21 @115 +@512 := @72 @511 +@519 := {vs : @111} -> {ts : @112} -> (h : @510) -> (hs : @189) -> @107 (@512 @28) @224 +@520 := @507 @71 +@521 := @21 @30 +@523 := @13 @521 @23 +@525 := @72 @494 @71 +@530 := {ts : @112} -> (h : @523) -> (hs : @235) -> @107 @525 @224 +@531 := @520 @77 +@533 := @72 @508 @71 +@534 := @107 @533 +@537 := (h : @447) -> (hs : @109) -> @534 @80 +@538 := @531 @445 +@540 := @72 @521 @71 +@542 := @107 @540 @80 +@543 := (hs : @109) -> @542 +@544 := @538 @106 +@546 := @107 @449 @80 +@547 := @185 @441 +@548 := @5 @115 +@550 := @13 @548 @30 +@551 := @5 @121 +@552 := @72 @551 +@560 := {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @550) -> (hs : @189) -> @107 (@552 @28) @135 +@561 := @547 @10 +@562 := @5 @117 +@564 := @13 @562 @10 +@565 := @5 @113 +@566 := @72 @565 +@568 := @107 (@566 @28) +@569 := @78 @10 +@570 := @569 @30 +@575 := {vs : @111} -> {ts : @112} -> (h : @564) -> (hs : @189) -> @568 @570 +@576 := @561 @449 +@577 := @5 @28 +@579 := @13 @577 @10 +@580 := @534 @32 +@582 := @72 @548 @525 +@583 := @107 @582 +@587 := {ts : @112} -> (h : @579) -> (hs : @580) -> @583 @570 +@588 := @576 @80 +@590 := @13 @441 @10 +@592 := @72 @562 @533 +@593 := @107 @592 +@594 := @569 @80 +@597 := (h : @590) -> (hs : @542) -> @593 @594 +@598 := @588 @443 +@600 := @72 @577 @540 +@601 := @107 @600 +@603 := (hs : @546) -> @601 @594 +@604 := @598 @544 +@605 := @107 @451 +@606 := @605 @594 +@607 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.denote +@609 := @607 @30 @32 +@610 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.__fits_0 +@612 := @610 @30 @32 +@615 := Models.Main.step @30 @32 +@616 := Bool +@618 := @452 @616 @616 +@620 := @452 @3 @27 +@621 := LexLeanTarget.TargetSyntax.Value.bool +@622 := LexLeanPreservation.encPair +@626 := @622 @616 @616 @621 @621 +@630 := @622 @3 @27 @5 @21 +@636 := LexLeanPreservation.encExcept @618 @620 @626 @630 @615 +@639 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.root @30 @32 +@640 := Ne.{1} +@641 := LexLeanPreservation.Obs +@642 := @640 @641 +@643 := LexLeanPreservation.Rel +@646 := @642 (@643 @32 @4) +@647 := LexLeanPreservation.Obs.stuck +@650 := (f : @616) -> (v : @67) -> @646 @647 +@652 := LexLeanPreservation.Rust.rel_ne_stuck @612 +@659 := (v : @67) -> @642 (@643 (@610 @28 @30) @4) @647 +@660 := @652 @636 +@664 := @642 (@643 @612 @636) @647 +@665 := @110 @454 +@666 := LexLeanPreservation.Rust.FunSem +@667 := #9 +@673 := (n : @27) -> @666 @667 @127 @121 @4 @113 +@674 := @320 @470 +@675 := @319 @674 +@682 := LexLeanRuntime.index (@110 @470) @470 (LexLeanRuntime.instIndexableList @470) +@686 := @675 (@682 (@471 @667) @113) +@687 := @328 @470 +@688 := @687 @115 +@689 := @686 @688 +@690 := #10 +@694 := @82 @690 @667 @127 @115 +@695 := LexLeanTarget.TargetSyntax.Function.types +@696 := @695 @113 +@697 := @694 @696 +@698 := @320 @665 +@699 := @319 @698 +@700 := LexLeanTarget.TargetSemantics.bindAll +@701 := LexLeanTarget.TargetSyntax.Function.parameters +@706 := @699 (@700 (@701 @121) @113 @463) +@707 := @328 @665 +@708 := @707 @115 +@709 := @706 @708 +@710 := @320 @616 +@711 := @319 @710 +@712 := LexLeanPreservation.Rust.fnFallible +@713 := #11 +@716 := @711 (@712 @713 @667) +@717 := @328 @616 +@718 := @717 @115 +@719 := @716 @718 +@720 := LexLeanPreservation.RunConv +@721 := #13 +@725 := @720 @721 @690 @127 @115 +@727 := @642 @113 @647 +@728 := Exists.{1} +@729 := LexLeanPreservation.Rust.ROut +@730 := @728 @729 +@731 := And +@732 := LexLeanPreservation.Rust.RealizesFn +@736 := @731 (@732 @667 @127 @4) +@737 := LexLeanPreservation.Rust.RCI +@739 := @737 #15 +@740 := LexLeanPreservation.Rust.fnIdent +@741 := @740 @721 +@748 := (hne : @727) -> @730 (fun (ro : @729) => @736 (@739 @741 @713 @4)) +@763 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {f : @27} -> + {fn : @470} -> + {args : @111} -> + {env : @665} -> + {F : @616} -> + {o : @641} -> + (hB : @673) -> + (hfn : @689) -> (hwt : @697) -> (hbind : @709) -> (hF : @719) -> (hA : @725) -> @748 +@765 := LexLeanPreservation.Rust.compose @0 +@766 := @666 @0 +@771 := (n : @27) -> @766 @127 @121 @4 @113 +@772 := @682 @472 +@775 := @675 (@772 @113) @688 +@779 := @93 @667 @127 @115 @696 +@780 := @720 @0 +@783 := @780 @690 @127 @115 +@797 := {c : @25} -> + {A : @26} -> + {f : @27} -> + {fn : @470} -> + {args : @111} -> + {env : @665} -> + {F : @616} -> + {o : @641} -> + (hB : @771) -> + (hfn : @775) -> (hwt : @779) -> (hbind : @709) -> (hF : @719) -> (hA : @783) -> @748 +@798 := @765 @1 +@799 := @766 @1 +@803 := (n : @27) -> @799 @121 @4 @113 +@806 := @101 @127 @115 @696 +@807 := @712 @1 +@810 := @711 (@807 @667) @718 +@811 := @737 @1 +@821 := (hbind : @709) -> + (hF : @810) -> (hA : @783) -> (hne : @727) -> @730 (fun (ro : @729) => @736 (@811 @741 @713 @4)) +@831 := {A : @26} -> + {f : @27} -> + {fn : @470} -> + {args : @111} -> + {env : @665} -> {F : @616} -> {o : @641} -> (hB : @803) -> (hfn : @775) -> (hwt : @806) -> @821 +@832 := @798 @2 +@834 := @799 @2 @4 +@836 := (n : @27) -> @834 @113 +@837 := @107 @115 +@838 := @837 @696 +@847 := {f : @27} -> + {fn : @470} -> + {args : @111} -> + {env : @665} -> {F : @616} -> {o : @641} -> (hB : @836) -> (hfn : @775) -> (hwt : @838) -> @821 +@848 := @832 @9 +@850 := (n : @27) -> @834 @9 +@851 := @772 @9 +@852 := @675 @851 +@853 := @852 @688 +@854 := @807 @9 +@855 := @711 @854 +@856 := @855 @718 +@857 := @780 @9 +@859 := @857 @127 @115 +@861 := @811 (@740 @9) +@869 := (hF : @856) -> (hA : @859) -> (hne : @727) -> @730 (fun (ro : @729) => @736 (@861 @713 @4)) +@878 := {fn : @470} -> + {args : @111} -> + {env : @665} -> + {F : @616} -> {o : @641} -> (hB : @850) -> (hfn : @853) -> (hwt : @838) -> (hbind : @709) -> @869 +@879 := @848 @488 +@881 := @852 (@687 @488) +@882 := @695 @488 +@883 := @837 @882 +@885 := @700 (@701 @488) +@897 := {args : @111} -> + {env : @665} -> + {F : @616} -> + {o : @641} -> + (hB : @850) -> (hfn : @881) -> (hwt : @883) -> (hbind : @699 (@885 @113 @463) @708) -> @869 +@898 := @879 @451 +@900 := @552 (@498 @71) +@902 := @107 @900 @882 +@908 := @72 (@5 @127) (@72 (@21 @121) @71) +@912 := @699 (@885 @908 @463) @708 +@918 := @72 (@5 @690) (@72 (@21 @667) @71) +@920 := @857 @918 @115 +@922 := @72 (@5 @721) +@923 := #12 +@942 := {env : @665} -> + {F : @616} -> + {o : @641} -> + (hB : @850) -> + (hfn : @881) -> + (hwt : @902) -> + (hbind : @912) -> + (hF : @856) -> + (hA : @920) -> + (hne : @727) -> @730 (fun (ro : @729) => @736 (@861 (@922 (@72 (@21 @923) @71)) @4)) +@943 := @898 @468 +@945 := @566 (@512 @71) +@947 := @107 @945 @882 +@958 := @699 (@885 @900 @463) (@707 (@464 (@459 @497) (@464 (@461 @551) @463))) +@964 := @72 (@5 @667) (@72 (@21 @127) @71) +@986 := {F : @616} -> + {o : @641} -> + (hB : @850) -> + (hfn : @881) -> + (hwt : @947) -> + (hbind : @958) -> + (hF : @856) -> + (hA : @857 @964 @115) -> + (hne : @727) -> @730 (fun (ro : @729) => @736 (@861 (@72 (@5 @923) (@72 (@21 @713) @71)) @4)) +@987 := @943 @469 +@988 := @583 @882 +@999 := @699 (@885 @945 @463) (@707 (@464 (@459 @511) (@464 (@461 @565) @463))) +@1001 := @855 (@717 @469) +@1003 := @857 @908 @115 +@1004 := @732 @469 +@1026 := {o : @641} -> + (hB : @850) -> + (hfn : @881) -> + (hwt : @988) -> + (hbind : @999) -> + (hF : @1001) -> + (hA : @1003) -> + (hne : @727) -> + @730 (fun (ro : @729) => @731 (@1004 @127 @4) (@861 (@72 (@5 @713) (@72 (@21 @690) @71)) @4)) +@1027 := @987 @609 +@1028 := @593 @882 +@1039 := @699 (@885 @582 @463) (@707 (@464 (@459 @494) (@464 (@461 @548) @463))) +@1040 := @857 @900 +@1042 := @607 @121 @113 +@1043 := @1040 @1042 +@1045 := @607 @127 @121 +@1064 := (hB : @850) -> + (hfn : @881) -> + (hwt : @1028) -> + (hbind : @1039) -> + (hF : @1001) -> + (hA : @1043) -> + (hne : @642 @1045 @647) -> + @730 (fun (ro : @729) => @731 (@1004 (@607 @690 @667) @4) (@861 @918 @4)) +@1065 := @1027 @492 +@1066 := @601 @882 +@1077 := @699 (@885 @592 @463) (@707 (@464 (@459 @508) (@464 (@461 @562) @463))) +@1078 := @857 @945 +@1080 := @607 @113 @115 +@1099 := (hfn : @881) -> + (hwt : @1066) -> + (hbind : @1077) -> + (hF : @1001) -> + (hA : @1078 @1080) -> + (hne : @642 @1042 @647) -> + @730 (fun (ro : @729) => @731 (@1004 (@607 @667 @127) @4) (@861 @964 @4)) +@1102 := @1065 (@428 @674 @851) +@1103 := @605 @882 +@1114 := @699 (@885 @600 @463) (@707 (@464 (@459 @521) (@464 (@461 @577) @463))) +@1115 := @857 @582 +@1117 := @607 @115 @117 +@1133 := (hwt : @1103) -> + (hbind : @1114) -> + (hF : @1001) -> + (hA : @1115 @1117) -> + (hne : @642 @1080 @647) -> @730 (fun (ro : @729) => @731 (@1004 @1045 @4) (@861 @908 @4)) +@1134 := @1102 @604 +@1136 := @885 @451 @463 +@1139 := @699 @1136 (@707 @468) +@1140 := @857 @592 +@1142 := @607 @117 @28 +@1157 := (hbind : @1139) -> + (hF : @1001) -> + (hA : @1140 @1142) -> + (hne : @642 @1117 @647) -> @730 (fun (ro : @729) => @731 (@1004 @1042 @4) (@861 @900 @4)) +@1160 := @1134 (@428 @698 @1136) +@1161 := @857 @600 +@1163 := @607 @28 @30 +@1177 := (hF : @1001) -> + (hA : @1161 @1163) -> + (hne : @642 @1142 @647) -> @730 (fun (ro : @729) => @731 (@1004 @1080 @4) (@861 @945 @4)) +@1180 := @1160 (@428 @710 @854) +@1194 := (hA : @857 @451 @609) -> + (hne : @642 @1163 @647) -> @730 (fun (ro : @729) => @731 (@1004 @1117 @4) (@861 @582 @4)) +@1195 := @1180 @639 +@1206 := (hne : @642 @609 @647) -> @730 (fun (ro : @729) => @731 (@1004 @1142 @4) (@861 @592 @4)) +@1207 := @1195 @660 +@1213 := @731 (@1004 @1163 @4) (@861 @600 @4) +@1215 := @730 (fun (ro : @729) => @1213) +@1217 := @730 (fun (__e_ro : @729) => @1213) +@1218 := LexLeanPreservation.Rust.RepresentableL +@1219 := @5 @32 +@1221 := @72 @34 @71 +@1224 := @1218 (@72 @1219 @1221) +@1225 := (__e_hrep : @1224) -> @1217 +@1226 := fun (__e_hrep : @1224) => @1207 +@1227 := (cost : @27) -> @1225 +@1228 := fun (cost : @27) => @1226 +@1229 := (window : @3) -> @1227 +@1230 := fun (window : @3) => @1228 +\end{coremodule} +\end{lexlean} diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R5/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R5/Compose/RustStd.lean deleted file mode 100644 index c682d0270..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R5/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5 -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (s : Nat) (x : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat s), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.denote s x) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat s), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat s) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat x) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.root s x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R5/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R5/Compose/RustStd.lex.tex new file mode 100644 index 000000000..458d7559a --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R5/Compose/RustStd.lex.tex @@ -0,0 +1,471 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5, + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd.root : @932 := @933 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd.program +@1 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd.krate +@2 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@63 := Prod.{0, 0} +@64 := @63 @3 +@65 := @64 @54 +@66 := 1 +@69 := Prod.mk.{0, 0} @3 @54 +@70 := @69 @66 +@71 := @70 @50 +@72 := 0 +@73 := @69 @72 +@74 := @73 @6 +@75 := @55 @65 +@76 := @56 @65 +@78 := @76 @74 @75 +@80 := @76 @71 @78 +@81 := Bool.true +@82 := LexLeanTarget.TargetSyntax.Function +@83 := LexLeanTarget.TargetSyntax.Program.functions +@84 := @83 @0 +@85 := LexLeanTarget.TargetSyntax.Ty +@86 := @55 @3 +@87 := @55 @85 +@88 := LexLeanTarget.TargetSyntax.Ty.unit +@89 := LexLeanTarget.TargetSyntax.Value.unit +@92 := LexLeanTarget.TargetSyntax.Expr.value @88 @89 +@97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 +@102 := List.getD.{0} @82 @84 @72 @97 +@106 := fun (__e_n : @3) => + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd.root @17 @72 +@107 := LexLeanPreservation.Rust.WTL +@115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 +@117 := LexLeanPreservation.Rust.wtl_nil @0 +@118 := @107 @0 +@124 := {c : @9} -> {A : @10} -> @118 @15 @17 @57 @87 +@125 := @117 @1 +@126 := @118 @1 +@130 := {A : @10} -> @126 @17 @57 @87 +@131 := @125 @2 +@132 := @126 @2 +@133 := @132 @57 +@134 := @133 @87 +@135 := List.{0} +@136 := @135 @54 +@137 := @135 @85 +@138 := #6 +@139 := @11 @138 +@140 := #5 +@141 := @139 @140 +@142 := #4 +@145 := @141 @142 @12 @4 +@146 := #7 +@151 := @107 @146 @138 @140 @4 @15 +@152 := #8 +@155 := @107 @152 @146 @138 +@157 := @58 @140 @12 +@158 := @155 @157 +@159 := @56 @85 +@161 := @159 @142 @4 +@171 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @145) -> (hs : @151) -> @158 @161 +@173 := LexLeanPreservation.Rust.wtl_cons @0 +@193 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> + (h : @27 @140 @142 @12 @4) -> (hs : @118 @138 @140 @4 @15) -> @118 @146 @138 @157 @161 +@194 := @173 @1 +@210 := {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> (h : @36 @142 @12 @4) -> (hs : @126 @140 @4 @15) -> @126 @138 @157 @161 +@211 := @194 @2 +@213 := @43 @12 @4 +@215 := @132 @4 @15 +@223 := {v : @54} -> + {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @213) -> (hs : @215) -> @132 @157 @161 +@224 := @211 @50 +@225 := @5 @142 +@226 := @43 @225 +@227 := @226 @4 +@228 := @5 @138 +@229 := @58 @228 +@231 := @132 (@229 @12) +@237 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @227) -> (hs : @215) -> @231 @161 +@238 := @224 @7 +@239 := @5 @12 +@241 := @43 @239 @7 +@242 := @5 @140 +@243 := @58 @242 +@245 := @132 (@243 @12) +@246 := @159 @7 +@247 := @246 @4 +@252 := {vs : @136} -> {ts : @137} -> (h : @241) -> (hs : @215) -> @245 @247 +@253 := @238 @57 +@254 := @133 @15 +@255 := @58 @225 +@256 := @255 @57 +@261 := {ts : @137} -> (h : @49) -> (hs : @254) -> @132 @256 @247 +@262 := @253 @87 +@263 := @58 @239 +@264 := @263 @57 +@265 := @132 @264 +@266 := @246 @87 +@269 := (h : @53) -> (hs : @134) -> @265 @266 +@270 := @262 @51 +@271 := @61 @57 +@273 := @132 @271 @266 +@274 := (hs : @134) -> @273 +@275 := @270 @131 +@277 := @132 @60 @266 +@278 := @211 @6 +@280 := @43 @242 @4 +@281 := @5 @146 +@282 := @58 @281 +@290 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @280) -> (hs : @215) -> @132 (@282 @12) @161 +@291 := @278 @7 +@297 := {vs : @136} -> {ts : @137} -> (h : @226 @7) -> (hs : @215) -> @231 @247 +@298 := @291 @60 +@299 := @265 @15 +@300 := @243 @256 +@301 := @132 @300 +@305 := {ts : @137} -> (h : @241) -> (hs : @299) -> @301 @247 +@306 := @298 @266 +@307 := @255 @264 +@308 := @132 @307 +@309 := @246 @266 +@312 := (h : @49) -> (hs : @273) -> @308 @309 +@313 := @306 @47 +@314 := @263 @271 +@315 := @132 @314 +@317 := (hs : @277) -> @315 @309 +@318 := @313 @275 +@319 := @132 @62 +@320 := @319 @309 +@321 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.__fits_0 +@326 := @324 @4 @15 +@329 := Models.Main.ledgerPost @4 @15 +@330 := Bool +@332 := @63 @330 @330 +@333 := @64 @3 +@334 := LexLeanTarget.TargetSyntax.Value.bool +@335 := LexLeanPreservation.encPair +@339 := @335 @330 @330 @334 @334 +@343 := @335 @3 @3 @5 @5 +@349 := LexLeanPreservation.encExcept @332 @333 @339 @343 @329 +@352 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.root @4 @15 +@353 := Ne.{1} +@354 := LexLeanPreservation.Obs +@355 := @353 @354 +@356 := LexLeanPreservation.Rel +@359 := @355 (@356 @15 @17) +@360 := LexLeanPreservation.Obs.stuck +@363 := (f : @330) -> (v : @54) -> @359 @360 +@365 := LexLeanPreservation.Rust.rel_ne_stuck @326 +@372 := (v : @54) -> @355 (@356 (@324 @12 @4) @17) @360 +@373 := @365 @349 +@377 := @355 (@356 @326 @349) @360 +@378 := @135 @65 +@379 := LexLeanPreservation.Rust.FunSem +@380 := #9 +@386 := (n : @3) -> @379 @380 @152 @146 @17 @138 +@387 := Eq.{1} +@388 := Option.{0} +@389 := @388 @82 +@390 := @387 @389 +@397 := LexLeanRuntime.index (@135 @82) @82 (LexLeanRuntime.instIndexableList @82) +@401 := @390 (@397 (@83 @380) @138) +@402 := Option.some.{0} +@403 := @402 @82 +@404 := @403 @140 +@405 := @401 @404 +@406 := #10 +@410 := @107 @406 @380 @152 @140 +@411 := LexLeanTarget.TargetSyntax.Function.types +@412 := @411 @138 +@413 := @410 @412 +@414 := @388 @378 +@415 := @387 @414 +@416 := LexLeanTarget.TargetSemantics.bindAll +@417 := LexLeanTarget.TargetSyntax.Function.parameters +@422 := @415 (@416 (@417 @146) @138 @75) +@423 := @402 @378 +@424 := @423 @140 +@425 := @422 @424 +@426 := @388 @330 +@427 := @387 @426 +@428 := LexLeanPreservation.Rust.fnFallible +@429 := #11 +@432 := @427 (@428 @429 @380) +@433 := @402 @330 +@434 := @433 @140 +@435 := @432 @434 +@436 := LexLeanPreservation.RunConv +@437 := #13 +@441 := @436 @437 @406 @152 @140 +@443 := @355 @138 @360 +@444 := Exists.{1} +@445 := LexLeanPreservation.Rust.ROut +@446 := @444 @445 +@447 := And +@448 := LexLeanPreservation.Rust.RealizesFn +@452 := @447 (@448 @380 @152 @17) +@453 := LexLeanPreservation.Rust.RCI +@455 := @453 #15 +@456 := LexLeanPreservation.Rust.fnIdent +@457 := @456 @437 +@464 := (hne : @443) -> @446 (fun (ro : @445) => @452 (@455 @457 @429 @17)) +@479 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @378} -> + {F : @330} -> + {o : @354} -> + (hB : @386) -> + (hfn : @405) -> (hwt : @413) -> (hbind : @425) -> (hF : @435) -> (hA : @441) -> @464 +@481 := LexLeanPreservation.Rust.compose @0 +@482 := @379 @0 +@487 := (n : @3) -> @482 @152 @146 @17 @138 +@488 := @397 @84 +@491 := @390 (@488 @138) @404 +@495 := @118 @380 @152 @140 @412 +@496 := @436 @0 +@499 := @496 @406 @152 @140 +@513 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @378} -> + {F : @330} -> + {o : @354} -> + (hB : @487) -> + (hfn : @491) -> (hwt : @495) -> (hbind : @425) -> (hF : @435) -> (hA : @499) -> @464 +@514 := @481 @1 +@515 := @482 @1 +@519 := (n : @3) -> @515 @146 @17 @138 +@522 := @126 @152 @140 @412 +@523 := @428 @1 +@526 := @427 (@523 @380) @434 +@527 := @453 @1 +@537 := (hbind : @425) -> + (hF : @526) -> (hA : @499) -> (hne : @443) -> @446 (fun (ro : @445) => @452 (@527 @457 @429 @17)) +@547 := {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @378} -> {F : @330} -> {o : @354} -> (hB : @519) -> (hfn : @491) -> (hwt : @522) -> @537 +@548 := @514 @2 +@550 := @515 @2 @17 +@552 := (n : @3) -> @550 @138 +@553 := @132 @140 +@554 := @553 @412 +@563 := {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @378} -> {F : @330} -> {o : @354} -> (hB : @552) -> (hfn : @491) -> (hwt : @554) -> @537 +@564 := @548 @72 +@566 := (n : @3) -> @550 @72 +@567 := @488 @72 +@568 := @390 @567 +@569 := @568 @404 +@570 := @523 @72 +@571 := @427 @570 +@572 := @571 @434 +@573 := @496 @72 +@575 := @573 @152 @140 +@577 := @527 (@456 @72) +@585 := (hF : @572) -> (hA : @575) -> (hne : @443) -> @446 (fun (ro : @445) => @452 (@577 @429 @17)) +@594 := {fn : @82} -> + {args : @136} -> + {env : @378} -> + {F : @330} -> {o : @354} -> (hB : @566) -> (hfn : @569) -> (hwt : @554) -> (hbind : @425) -> @585 +@595 := @564 @102 +@597 := @568 (@403 @102) +@598 := @411 @102 +@599 := @553 @598 +@601 := @416 (@417 @102) +@613 := {args : @136} -> + {env : @378} -> + {F : @330} -> + {o : @354} -> + (hB : @566) -> (hfn : @597) -> (hwt : @599) -> (hbind : @415 (@601 @138 @75) @424) -> @585 +@614 := @595 @62 +@616 := @282 (@229 @57) +@618 := @132 @616 @598 +@620 := @58 (@5 @152) +@622 := @620 (@282 @57) +@626 := @415 (@601 @622 @75) @424 +@628 := @58 (@5 @406) +@630 := @58 (@5 @380) +@632 := @628 (@630 @57) +@634 := @573 @632 @140 +@636 := @58 (@5 @437) +@639 := @58 (@5 #12) +@656 := {env : @378} -> + {F : @330} -> + {o : @354} -> + (hB : @566) -> + (hfn : @597) -> + (hwt : @618) -> + (hbind : @626) -> + (hF : @572) -> + (hA : @634) -> (hne : @443) -> @446 (fun (ro : @445) => @452 (@577 (@636 (@639 @57)) @17)) +@657 := @614 @80 +@659 := @229 (@243 @57) +@661 := @132 @659 @598 +@672 := @415 (@601 @616 @75) (@423 (@76 (@70 @228) (@76 (@73 @281) @75))) +@674 := @630 (@620 @57) +@676 := @573 @674 @140 +@678 := @58 (@5 @429) +@694 := {F : @330} -> + {o : @354} -> + (hB : @566) -> + (hfn : @597) -> + (hwt : @661) -> + (hbind : @672) -> + (hF : @572) -> + (hA : @676) -> (hne : @443) -> @446 (fun (ro : @445) => @452 (@577 (@639 (@678 @57)) @17)) +@695 := @657 @81 +@696 := @301 @598 +@707 := @415 (@601 @659 @75) (@423 (@76 (@70 @242) (@76 (@73 @228) @75))) +@709 := @571 (@433 @81) +@711 := @573 @622 @140 +@712 := @448 @81 +@730 := {o : @354} -> + (hB : @566) -> + (hfn : @597) -> + (hwt : @696) -> + (hbind : @707) -> + (hF : @709) -> + (hA : @711) -> + (hne : @443) -> @446 (fun (ro : @445) => @447 (@712 @152 @17) (@577 (@678 (@628 @57)) @17)) +@731 := @695 @323 +@732 := @308 @598 +@743 := @415 (@601 @300 @75) (@423 (@76 (@70 @225) (@76 (@73 @242) @75))) +@744 := @573 @616 +@746 := @321 @146 @138 +@747 := @744 @746 +@749 := @321 @152 @146 +@768 := (hB : @566) -> + (hfn : @597) -> + (hwt : @732) -> + (hbind : @743) -> + (hF : @709) -> + (hA : @747) -> + (hne : @355 @749 @360) -> + @446 (fun (ro : @445) => @447 (@712 (@321 @406 @380) @17) (@577 @632 @17)) +@769 := @731 @106 +@770 := @315 @598 +@781 := @415 (@601 @307 @75) (@423 (@76 (@70 @239) (@76 (@73 @225) @75))) +@782 := @573 @659 +@784 := @321 @138 @140 +@803 := (hfn : @597) -> + (hwt : @770) -> + (hbind : @781) -> + (hF : @709) -> + (hA : @782 @784) -> + (hne : @355 @746 @360) -> + @446 (fun (ro : @445) => @447 (@712 (@321 @380 @152) @17) (@577 @674 @17)) +@804 := Eq.refl.{1} +@807 := @769 (@804 @389 @567) +@808 := @319 @598 +@819 := @415 (@601 @314 @75) (@423 (@76 (@70 @6) (@76 (@73 @239) @75))) +@820 := @573 @300 +@822 := @321 @140 @142 +@838 := (hwt : @808) -> + (hbind : @819) -> + (hF : @709) -> + (hA : @820 @822) -> + (hne : @355 @784 @360) -> @446 (fun (ro : @445) => @447 (@712 @749 @17) (@577 @622 @17)) +@839 := @807 @318 +@841 := @601 @62 @75 +@844 := @415 @841 (@423 @80) +@845 := @573 @307 +@847 := @321 @142 @12 +@862 := (hbind : @844) -> + (hF : @709) -> + (hA : @845 @847) -> + (hne : @355 @822 @360) -> @446 (fun (ro : @445) => @447 (@712 @746 @17) (@577 @616 @17)) +@865 := @839 (@804 @414 @841) +@866 := @573 @314 +@868 := @321 @12 @4 +@882 := (hF : @709) -> + (hA : @866 @868) -> + (hne : @355 @847 @360) -> @446 (fun (ro : @445) => @447 (@712 @784 @17) (@577 @659 @17)) +@885 := @865 (@804 @426 @570) +@899 := (hA : @573 @62 @323) -> + (hne : @355 @868 @360) -> @446 (fun (ro : @445) => @447 (@712 @822 @17) (@577 @300 @17)) +@900 := @885 @352 +@911 := (hne : @355 @323 @360) -> @446 (fun (ro : @445) => @447 (@712 @847 @17) (@577 @307 @17)) +@912 := @900 @373 +@918 := @447 (@712 @868 @17) (@577 @314 @17) +@920 := @446 (fun (ro : @445) => @918) +@922 := @446 (fun (__e_ro : @445) => @918) +@927 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@928 := (__e_hrep : @927) -> @922 +@929 := fun (__e_hrep : @927) => @912 +@930 := (x : @3) -> @928 +@931 := fun (x : @3) => @929 +@932 := (s : @3) -> @930 +@933 := fun (s : @3) => @931 +\end{coremodule} +\end{lexlean} diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R6/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R6/Compose/RustStd.lean deleted file mode 100644 index 611286801..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R6/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6 -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (s : Nat) (x : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat s), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.denote s x) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat s), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat s) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat x) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.root s x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R6/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R6/Compose/RustStd.lex.tex new file mode 100644 index 000000000..71a9e25fc --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R6/Compose/RustStd.lex.tex @@ -0,0 +1,471 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6, + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd.root : @932 := @933 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd.program +@1 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd.krate +@2 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@63 := Prod.{0, 0} +@64 := @63 @3 +@65 := @64 @54 +@66 := 1 +@69 := Prod.mk.{0, 0} @3 @54 +@70 := @69 @66 +@71 := @70 @50 +@72 := 0 +@73 := @69 @72 +@74 := @73 @6 +@75 := @55 @65 +@76 := @56 @65 +@78 := @76 @74 @75 +@80 := @76 @71 @78 +@81 := Bool.true +@82 := LexLeanTarget.TargetSyntax.Function +@83 := LexLeanTarget.TargetSyntax.Program.functions +@84 := @83 @0 +@85 := LexLeanTarget.TargetSyntax.Ty +@86 := @55 @3 +@87 := @55 @85 +@88 := LexLeanTarget.TargetSyntax.Ty.unit +@89 := LexLeanTarget.TargetSyntax.Value.unit +@92 := LexLeanTarget.TargetSyntax.Expr.value @88 @89 +@97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 +@102 := List.getD.{0} @82 @84 @72 @97 +@106 := fun (__e_n : @3) => + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd.root @17 @72 +@107 := LexLeanPreservation.Rust.WTL +@115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 +@117 := LexLeanPreservation.Rust.wtl_nil @0 +@118 := @107 @0 +@124 := {c : @9} -> {A : @10} -> @118 @15 @17 @57 @87 +@125 := @117 @1 +@126 := @118 @1 +@130 := {A : @10} -> @126 @17 @57 @87 +@131 := @125 @2 +@132 := @126 @2 +@133 := @132 @57 +@134 := @133 @87 +@135 := List.{0} +@136 := @135 @54 +@137 := @135 @85 +@138 := #6 +@139 := @11 @138 +@140 := #5 +@141 := @139 @140 +@142 := #4 +@145 := @141 @142 @12 @4 +@146 := #7 +@151 := @107 @146 @138 @140 @4 @15 +@152 := #8 +@155 := @107 @152 @146 @138 +@157 := @58 @140 @12 +@158 := @155 @157 +@159 := @56 @85 +@161 := @159 @142 @4 +@171 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @145) -> (hs : @151) -> @158 @161 +@173 := LexLeanPreservation.Rust.wtl_cons @0 +@193 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> + (h : @27 @140 @142 @12 @4) -> (hs : @118 @138 @140 @4 @15) -> @118 @146 @138 @157 @161 +@194 := @173 @1 +@210 := {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> (h : @36 @142 @12 @4) -> (hs : @126 @140 @4 @15) -> @126 @138 @157 @161 +@211 := @194 @2 +@213 := @43 @12 @4 +@215 := @132 @4 @15 +@223 := {v : @54} -> + {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @213) -> (hs : @215) -> @132 @157 @161 +@224 := @211 @50 +@225 := @5 @142 +@226 := @43 @225 +@227 := @226 @4 +@228 := @5 @138 +@229 := @58 @228 +@231 := @132 (@229 @12) +@237 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @227) -> (hs : @215) -> @231 @161 +@238 := @224 @7 +@239 := @5 @12 +@241 := @43 @239 @7 +@242 := @5 @140 +@243 := @58 @242 +@245 := @132 (@243 @12) +@246 := @159 @7 +@247 := @246 @4 +@252 := {vs : @136} -> {ts : @137} -> (h : @241) -> (hs : @215) -> @245 @247 +@253 := @238 @57 +@254 := @133 @15 +@255 := @58 @225 +@256 := @255 @57 +@261 := {ts : @137} -> (h : @49) -> (hs : @254) -> @132 @256 @247 +@262 := @253 @87 +@263 := @58 @239 +@264 := @263 @57 +@265 := @132 @264 +@266 := @246 @87 +@269 := (h : @53) -> (hs : @134) -> @265 @266 +@270 := @262 @51 +@271 := @61 @57 +@273 := @132 @271 @266 +@274 := (hs : @134) -> @273 +@275 := @270 @131 +@277 := @132 @60 @266 +@278 := @211 @6 +@280 := @43 @242 @4 +@281 := @5 @146 +@282 := @58 @281 +@290 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @280) -> (hs : @215) -> @132 (@282 @12) @161 +@291 := @278 @7 +@297 := {vs : @136} -> {ts : @137} -> (h : @226 @7) -> (hs : @215) -> @231 @247 +@298 := @291 @60 +@299 := @265 @15 +@300 := @243 @256 +@301 := @132 @300 +@305 := {ts : @137} -> (h : @241) -> (hs : @299) -> @301 @247 +@306 := @298 @266 +@307 := @255 @264 +@308 := @132 @307 +@309 := @246 @266 +@312 := (h : @49) -> (hs : @273) -> @308 @309 +@313 := @306 @47 +@314 := @263 @271 +@315 := @132 @314 +@317 := (hs : @277) -> @315 @309 +@318 := @313 @275 +@319 := @132 @62 +@320 := @319 @309 +@321 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.__fits_0 +@326 := @324 @4 @15 +@329 := Models.Main.ledgerFull @4 @15 +@330 := Bool +@332 := @63 @330 @330 +@333 := @64 @3 +@334 := LexLeanTarget.TargetSyntax.Value.bool +@335 := LexLeanPreservation.encPair +@339 := @335 @330 @330 @334 @334 +@343 := @335 @3 @3 @5 @5 +@349 := LexLeanPreservation.encExcept @332 @333 @339 @343 @329 +@352 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.root @4 @15 +@353 := Ne.{1} +@354 := LexLeanPreservation.Obs +@355 := @353 @354 +@356 := LexLeanPreservation.Rel +@359 := @355 (@356 @15 @17) +@360 := LexLeanPreservation.Obs.stuck +@363 := (f : @330) -> (v : @54) -> @359 @360 +@365 := LexLeanPreservation.Rust.rel_ne_stuck @326 +@372 := (v : @54) -> @355 (@356 (@324 @12 @4) @17) @360 +@373 := @365 @349 +@377 := @355 (@356 @326 @349) @360 +@378 := @135 @65 +@379 := LexLeanPreservation.Rust.FunSem +@380 := #9 +@386 := (n : @3) -> @379 @380 @152 @146 @17 @138 +@387 := Eq.{1} +@388 := Option.{0} +@389 := @388 @82 +@390 := @387 @389 +@397 := LexLeanRuntime.index (@135 @82) @82 (LexLeanRuntime.instIndexableList @82) +@401 := @390 (@397 (@83 @380) @138) +@402 := Option.some.{0} +@403 := @402 @82 +@404 := @403 @140 +@405 := @401 @404 +@406 := #10 +@410 := @107 @406 @380 @152 @140 +@411 := LexLeanTarget.TargetSyntax.Function.types +@412 := @411 @138 +@413 := @410 @412 +@414 := @388 @378 +@415 := @387 @414 +@416 := LexLeanTarget.TargetSemantics.bindAll +@417 := LexLeanTarget.TargetSyntax.Function.parameters +@422 := @415 (@416 (@417 @146) @138 @75) +@423 := @402 @378 +@424 := @423 @140 +@425 := @422 @424 +@426 := @388 @330 +@427 := @387 @426 +@428 := LexLeanPreservation.Rust.fnFallible +@429 := #11 +@432 := @427 (@428 @429 @380) +@433 := @402 @330 +@434 := @433 @140 +@435 := @432 @434 +@436 := LexLeanPreservation.RunConv +@437 := #13 +@441 := @436 @437 @406 @152 @140 +@443 := @355 @138 @360 +@444 := Exists.{1} +@445 := LexLeanPreservation.Rust.ROut +@446 := @444 @445 +@447 := And +@448 := LexLeanPreservation.Rust.RealizesFn +@452 := @447 (@448 @380 @152 @17) +@453 := LexLeanPreservation.Rust.RCI +@455 := @453 #15 +@456 := LexLeanPreservation.Rust.fnIdent +@457 := @456 @437 +@464 := (hne : @443) -> @446 (fun (ro : @445) => @452 (@455 @457 @429 @17)) +@479 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @378} -> + {F : @330} -> + {o : @354} -> + (hB : @386) -> + (hfn : @405) -> (hwt : @413) -> (hbind : @425) -> (hF : @435) -> (hA : @441) -> @464 +@481 := LexLeanPreservation.Rust.compose @0 +@482 := @379 @0 +@487 := (n : @3) -> @482 @152 @146 @17 @138 +@488 := @397 @84 +@491 := @390 (@488 @138) @404 +@495 := @118 @380 @152 @140 @412 +@496 := @436 @0 +@499 := @496 @406 @152 @140 +@513 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @378} -> + {F : @330} -> + {o : @354} -> + (hB : @487) -> + (hfn : @491) -> (hwt : @495) -> (hbind : @425) -> (hF : @435) -> (hA : @499) -> @464 +@514 := @481 @1 +@515 := @482 @1 +@519 := (n : @3) -> @515 @146 @17 @138 +@522 := @126 @152 @140 @412 +@523 := @428 @1 +@526 := @427 (@523 @380) @434 +@527 := @453 @1 +@537 := (hbind : @425) -> + (hF : @526) -> (hA : @499) -> (hne : @443) -> @446 (fun (ro : @445) => @452 (@527 @457 @429 @17)) +@547 := {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @378} -> {F : @330} -> {o : @354} -> (hB : @519) -> (hfn : @491) -> (hwt : @522) -> @537 +@548 := @514 @2 +@550 := @515 @2 @17 +@552 := (n : @3) -> @550 @138 +@553 := @132 @140 +@554 := @553 @412 +@563 := {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @378} -> {F : @330} -> {o : @354} -> (hB : @552) -> (hfn : @491) -> (hwt : @554) -> @537 +@564 := @548 @72 +@566 := (n : @3) -> @550 @72 +@567 := @488 @72 +@568 := @390 @567 +@569 := @568 @404 +@570 := @523 @72 +@571 := @427 @570 +@572 := @571 @434 +@573 := @496 @72 +@575 := @573 @152 @140 +@577 := @527 (@456 @72) +@585 := (hF : @572) -> (hA : @575) -> (hne : @443) -> @446 (fun (ro : @445) => @452 (@577 @429 @17)) +@594 := {fn : @82} -> + {args : @136} -> + {env : @378} -> + {F : @330} -> {o : @354} -> (hB : @566) -> (hfn : @569) -> (hwt : @554) -> (hbind : @425) -> @585 +@595 := @564 @102 +@597 := @568 (@403 @102) +@598 := @411 @102 +@599 := @553 @598 +@601 := @416 (@417 @102) +@613 := {args : @136} -> + {env : @378} -> + {F : @330} -> + {o : @354} -> + (hB : @566) -> (hfn : @597) -> (hwt : @599) -> (hbind : @415 (@601 @138 @75) @424) -> @585 +@614 := @595 @62 +@616 := @282 (@229 @57) +@618 := @132 @616 @598 +@620 := @58 (@5 @152) +@622 := @620 (@282 @57) +@626 := @415 (@601 @622 @75) @424 +@628 := @58 (@5 @406) +@630 := @58 (@5 @380) +@632 := @628 (@630 @57) +@634 := @573 @632 @140 +@636 := @58 (@5 @437) +@639 := @58 (@5 #12) +@656 := {env : @378} -> + {F : @330} -> + {o : @354} -> + (hB : @566) -> + (hfn : @597) -> + (hwt : @618) -> + (hbind : @626) -> + (hF : @572) -> + (hA : @634) -> (hne : @443) -> @446 (fun (ro : @445) => @452 (@577 (@636 (@639 @57)) @17)) +@657 := @614 @80 +@659 := @229 (@243 @57) +@661 := @132 @659 @598 +@672 := @415 (@601 @616 @75) (@423 (@76 (@70 @228) (@76 (@73 @281) @75))) +@674 := @630 (@620 @57) +@676 := @573 @674 @140 +@678 := @58 (@5 @429) +@694 := {F : @330} -> + {o : @354} -> + (hB : @566) -> + (hfn : @597) -> + (hwt : @661) -> + (hbind : @672) -> + (hF : @572) -> + (hA : @676) -> (hne : @443) -> @446 (fun (ro : @445) => @452 (@577 (@639 (@678 @57)) @17)) +@695 := @657 @81 +@696 := @301 @598 +@707 := @415 (@601 @659 @75) (@423 (@76 (@70 @242) (@76 (@73 @228) @75))) +@709 := @571 (@433 @81) +@711 := @573 @622 @140 +@712 := @448 @81 +@730 := {o : @354} -> + (hB : @566) -> + (hfn : @597) -> + (hwt : @696) -> + (hbind : @707) -> + (hF : @709) -> + (hA : @711) -> + (hne : @443) -> @446 (fun (ro : @445) => @447 (@712 @152 @17) (@577 (@678 (@628 @57)) @17)) +@731 := @695 @323 +@732 := @308 @598 +@743 := @415 (@601 @300 @75) (@423 (@76 (@70 @225) (@76 (@73 @242) @75))) +@744 := @573 @616 +@746 := @321 @146 @138 +@747 := @744 @746 +@749 := @321 @152 @146 +@768 := (hB : @566) -> + (hfn : @597) -> + (hwt : @732) -> + (hbind : @743) -> + (hF : @709) -> + (hA : @747) -> + (hne : @355 @749 @360) -> + @446 (fun (ro : @445) => @447 (@712 (@321 @406 @380) @17) (@577 @632 @17)) +@769 := @731 @106 +@770 := @315 @598 +@781 := @415 (@601 @307 @75) (@423 (@76 (@70 @239) (@76 (@73 @225) @75))) +@782 := @573 @659 +@784 := @321 @138 @140 +@803 := (hfn : @597) -> + (hwt : @770) -> + (hbind : @781) -> + (hF : @709) -> + (hA : @782 @784) -> + (hne : @355 @746 @360) -> + @446 (fun (ro : @445) => @447 (@712 (@321 @380 @152) @17) (@577 @674 @17)) +@804 := Eq.refl.{1} +@807 := @769 (@804 @389 @567) +@808 := @319 @598 +@819 := @415 (@601 @314 @75) (@423 (@76 (@70 @6) (@76 (@73 @239) @75))) +@820 := @573 @300 +@822 := @321 @140 @142 +@838 := (hwt : @808) -> + (hbind : @819) -> + (hF : @709) -> + (hA : @820 @822) -> + (hne : @355 @784 @360) -> @446 (fun (ro : @445) => @447 (@712 @749 @17) (@577 @622 @17)) +@839 := @807 @318 +@841 := @601 @62 @75 +@844 := @415 @841 (@423 @80) +@845 := @573 @307 +@847 := @321 @142 @12 +@862 := (hbind : @844) -> + (hF : @709) -> + (hA : @845 @847) -> + (hne : @355 @822 @360) -> @446 (fun (ro : @445) => @447 (@712 @746 @17) (@577 @616 @17)) +@865 := @839 (@804 @414 @841) +@866 := @573 @314 +@868 := @321 @12 @4 +@882 := (hF : @709) -> + (hA : @866 @868) -> + (hne : @355 @847 @360) -> @446 (fun (ro : @445) => @447 (@712 @784 @17) (@577 @659 @17)) +@885 := @865 (@804 @426 @570) +@899 := (hA : @573 @62 @323) -> + (hne : @355 @868 @360) -> @446 (fun (ro : @445) => @447 (@712 @822 @17) (@577 @300 @17)) +@900 := @885 @352 +@911 := (hne : @355 @323 @360) -> @446 (fun (ro : @445) => @447 (@712 @847 @17) (@577 @307 @17)) +@912 := @900 @373 +@918 := @447 (@712 @868 @17) (@577 @314 @17) +@920 := @446 (fun (ro : @445) => @918) +@922 := @446 (fun (__e_ro : @445) => @918) +@927 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@928 := (__e_hrep : @927) -> @922 +@929 := fun (__e_hrep : @927) => @912 +@930 := (x : @3) -> @928 +@931 := fun (x : @3) => @929 +@932 := (s : @3) -> @930 +@933 := fun (s : @3) => @931 +\end{coremodule} +\end{lexlean} diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R7/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R7/Compose/RustStd.lean deleted file mode 100644 index 39a02826b..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R7/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7 -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (x : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat x)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.denote x) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat x)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat x) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.root x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R7/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R7/Compose/RustStd.lex.tex new file mode 100644 index 000000000..d0a3f0559 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R7/Compose/RustStd.lex.tex @@ -0,0 +1,421 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7, + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd.root : @838 := @839 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd.program +@1 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd.krate +@2 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd.flags +@3 := Nat +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@57 := Prod.{0, 0} +@59 := @57 @3 @50 +@60 := 0 +@64 := Prod.mk.{0, 0} @3 @50 @60 +@65 := @64 @6 +@66 := @51 @59 +@67 := @52 @59 +@69 := @67 @65 @66 +@70 := Bool.false +@71 := LexLeanTarget.TargetSyntax.Function +@72 := LexLeanTarget.TargetSyntax.Program.functions +@73 := @72 @0 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := @51 @3 +@76 := @51 @74 +@77 := LexLeanTarget.TargetSyntax.Ty.unit +@78 := LexLeanTarget.TargetSyntax.Value.unit +@81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 +@86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 +@91 := List.getD.{0} @71 @73 @60 @86 +@95 := fun (__e_n : @3) => LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd.root @17 @60 +@96 := LexLeanPreservation.Rust.WTL +@104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 +@106 := LexLeanPreservation.Rust.wtl_nil @0 +@107 := @96 @0 +@113 := {c : @9} -> {A : @10} -> @107 @4 @17 @53 @76 +@114 := @106 @1 +@115 := @107 @1 +@119 := {A : @10} -> @115 @17 @53 @76 +@120 := @114 @2 +@121 := @115 @2 +@122 := @121 @53 +@123 := @122 @76 +@124 := List.{0} +@125 := @124 @50 +@126 := @124 @74 +@127 := #6 +@128 := @11 @127 +@129 := #5 +@130 := @128 @129 +@131 := #4 +@134 := @130 @131 @12 @14 +@135 := #7 +@140 := @96 @135 @127 @129 @14 @4 +@141 := #8 +@144 := @96 @141 @135 @127 +@146 := @54 @129 @12 +@147 := @144 @146 +@148 := @52 @74 +@150 := @148 @131 @14 +@160 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @134) -> (hs : @140) -> @147 @150 +@162 := LexLeanPreservation.Rust.wtl_cons @0 +@182 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> + (h : @27 @129 @131 @12 @14) -> (hs : @107 @127 @129 @14 @4) -> @107 @135 @127 @146 @150 +@183 := @162 @1 +@199 := {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> (h : @36 @131 @12 @14) -> (hs : @115 @129 @14 @4) -> @115 @127 @146 @150 +@200 := @183 @2 +@202 := @43 @12 @14 +@204 := @121 @14 @4 +@212 := {v : @50} -> + {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @202) -> (hs : @204) -> @121 @146 @150 +@213 := @200 @6 +@214 := @5 @131 +@216 := @43 @214 @14 +@217 := @5 @127 +@218 := @54 @217 +@226 := {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @216) -> (hs : @204) -> @121 (@218 @12) @150 +@227 := @213 @7 +@228 := @5 @12 +@230 := @43 @228 @7 +@231 := @5 @129 +@232 := @54 @231 +@234 := @121 (@232 @12) +@235 := @148 @7 +@236 := @235 @14 +@241 := {vs : @125} -> {ts : @126} -> (h : @230) -> (hs : @204) -> @234 @236 +@242 := @227 @53 +@243 := @5 @14 +@245 := @43 @243 @7 +@246 := @122 @4 +@248 := @54 @214 @53 +@249 := @121 @248 +@253 := {ts : @126} -> (h : @245) -> (hs : @246) -> @249 @236 +@254 := @242 @76 +@256 := @54 @228 @53 +@257 := @121 @256 +@258 := @235 @76 +@261 := (h : @49) -> (hs : @123) -> @257 @258 +@262 := @254 @47 +@264 := @54 @243 @53 +@265 := @121 @264 +@267 := (hs : @123) -> @265 @258 +@268 := @262 @120 +@269 := @121 @56 +@270 := @269 @258 +@271 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.__fits_0 +@274 := @273 @4 +@276 := Models.Main.guessChecked @4 +@277 := Bool +@279 := @57 @277 @277 +@280 := LexLeanTarget.TargetSyntax.Value.bool +@285 := LexLeanPreservation.encPair @277 @277 @280 @280 +@291 := LexLeanPreservation.encExcept @279 @3 @285 @5 @276 +@293 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.root @4 +@294 := Ne.{1} +@295 := LexLeanPreservation.Obs +@296 := @294 @295 +@297 := LexLeanPreservation.Rel +@300 := @296 (@297 @4 @17) +@301 := LexLeanPreservation.Obs.stuck +@304 := (f : @277) -> (v : @50) -> @300 @301 +@306 := LexLeanPreservation.Rust.rel_ne_stuck @274 +@312 := (v : @50) -> @296 (@297 (@273 @14) @17) @301 +@313 := @306 @291 +@317 := @296 (@297 @274 @291) @301 +@318 := @124 @59 +@319 := LexLeanPreservation.Rust.FunSem +@320 := #9 +@326 := (n : @3) -> @319 @320 @141 @135 @17 @127 +@327 := Eq.{1} +@328 := Option.{0} +@329 := @328 @71 +@330 := @327 @329 +@337 := LexLeanRuntime.index (@124 @71) @71 (LexLeanRuntime.instIndexableList @71) +@341 := @330 (@337 (@72 @320) @127) +@342 := Option.some.{0} +@343 := @342 @71 +@344 := @343 @129 +@345 := @341 @344 +@346 := #10 +@350 := @96 @346 @320 @141 @129 +@351 := LexLeanTarget.TargetSyntax.Function.types +@352 := @351 @127 +@353 := @350 @352 +@354 := @328 @318 +@355 := @327 @354 +@356 := LexLeanTarget.TargetSemantics.bindAll +@357 := LexLeanTarget.TargetSyntax.Function.parameters +@362 := @355 (@356 (@357 @135) @127 @66) +@363 := @342 @318 +@364 := @363 @129 +@365 := @362 @364 +@366 := @328 @277 +@367 := @327 @366 +@368 := LexLeanPreservation.Rust.fnFallible +@369 := #11 +@372 := @367 (@368 @369 @320) +@373 := @342 @277 +@374 := @373 @129 +@375 := @372 @374 +@376 := LexLeanPreservation.RunConv +@377 := #13 +@381 := @376 @377 @346 @141 @129 +@383 := @296 @127 @301 +@384 := Exists.{1} +@385 := LexLeanPreservation.Rust.ROut +@386 := @384 @385 +@387 := And +@388 := LexLeanPreservation.Rust.RealizesFn +@392 := @387 (@388 @320 @141 @17) +@393 := LexLeanPreservation.Rust.RCI +@395 := @393 #15 +@396 := LexLeanPreservation.Rust.fnIdent +@397 := @396 @377 +@404 := (hne : @383) -> @386 (fun (ro : @385) => @392 (@395 @397 @369 @17)) +@419 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @318} -> + {F : @277} -> + {o : @295} -> + (hB : @326) -> + (hfn : @345) -> (hwt : @353) -> (hbind : @365) -> (hF : @375) -> (hA : @381) -> @404 +@421 := LexLeanPreservation.Rust.compose @0 +@422 := @319 @0 +@427 := (n : @3) -> @422 @141 @135 @17 @127 +@428 := @337 @73 +@431 := @330 (@428 @127) @344 +@435 := @107 @320 @141 @129 @352 +@436 := @376 @0 +@439 := @436 @346 @141 @129 +@453 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @318} -> + {F : @277} -> + {o : @295} -> + (hB : @427) -> + (hfn : @431) -> (hwt : @435) -> (hbind : @365) -> (hF : @375) -> (hA : @439) -> @404 +@454 := @421 @1 +@455 := @422 @1 +@459 := (n : @3) -> @455 @135 @17 @127 +@462 := @115 @141 @129 @352 +@463 := @368 @1 +@466 := @367 (@463 @320) @374 +@467 := @393 @1 +@477 := (hbind : @365) -> + (hF : @466) -> (hA : @439) -> (hne : @383) -> @386 (fun (ro : @385) => @392 (@467 @397 @369 @17)) +@487 := {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @318} -> {F : @277} -> {o : @295} -> (hB : @459) -> (hfn : @431) -> (hwt : @462) -> @477 +@488 := @454 @2 +@490 := @455 @2 @17 +@492 := (n : @3) -> @490 @127 +@493 := @121 @129 +@494 := @493 @352 +@503 := {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @318} -> {F : @277} -> {o : @295} -> (hB : @492) -> (hfn : @431) -> (hwt : @494) -> @477 +@504 := @488 @60 +@506 := (n : @3) -> @490 @60 +@507 := @428 @60 +@508 := @330 @507 +@509 := @508 @344 +@510 := @463 @60 +@511 := @367 @510 +@512 := @511 @374 +@513 := @436 @60 +@515 := @513 @141 @129 +@517 := @467 (@396 @60) +@525 := (hF : @512) -> (hA : @515) -> (hne : @383) -> @386 (fun (ro : @385) => @392 (@517 @369 @17)) +@534 := {fn : @71} -> + {args : @125} -> + {env : @318} -> + {F : @277} -> {o : @295} -> (hB : @506) -> (hfn : @509) -> (hwt : @494) -> (hbind : @365) -> @525 +@535 := @504 @91 +@537 := @508 (@343 @91) +@538 := @351 @91 +@539 := @493 @538 +@541 := @356 (@357 @91) +@553 := {args : @125} -> + {env : @318} -> + {F : @277} -> + {o : @295} -> + (hB : @506) -> (hfn : @537) -> (hwt : @539) -> (hbind : @355 (@541 @127 @66) @364) -> @525 +@554 := @535 @56 +@555 := @218 @53 +@557 := @121 @555 @538 +@560 := @54 (@5 @135) @53 +@564 := @355 (@541 @560 @66) @364 +@567 := @54 (@5 @320) @53 +@588 := {env : @318} -> + {F : @277} -> + {o : @295} -> + (hB : @506) -> + (hfn : @537) -> + (hwt : @557) -> + (hbind : @564) -> + (hF : @512) -> + (hA : @513 @567 @129) -> + (hne : @383) -> @386 (fun (ro : @385) => @392 (@517 (@54 (@5 #12) @53) @17)) +@589 := @554 @69 +@590 := @232 @53 +@592 := @121 @590 @538 +@600 := @355 (@541 @555 @66) (@363 (@67 (@64 @217) @66)) +@603 := @54 (@5 @141) @53 +@622 := {F : @277} -> + {o : @295} -> + (hB : @506) -> + (hfn : @537) -> + (hwt : @592) -> + (hbind : @600) -> + (hF : @512) -> + (hA : @513 @603 @129) -> + (hne : @383) -> @386 (fun (ro : @385) => @392 (@517 (@54 (@5 @369) @53) @17)) +@623 := @589 @70 +@624 := @249 @538 +@632 := @355 (@541 @590 @66) (@363 (@67 (@64 @231) @66)) +@634 := @511 (@373 @70) +@636 := @513 @560 @129 +@637 := @388 @70 +@656 := {o : @295} -> + (hB : @506) -> + (hfn : @537) -> + (hwt : @624) -> + (hbind : @632) -> + (hF : @634) -> + (hA : @636) -> + (hne : @383) -> @386 (fun (ro : @385) => @387 (@637 @141 @17) (@517 (@54 (@5 @346) @53) @17)) +@657 := @623 @272 +@658 := @257 @538 +@666 := @355 (@541 @248 @66) (@363 (@67 (@64 @214) @66)) +@667 := @513 @555 +@668 := @271 @127 +@669 := @667 @668 +@670 := @271 @135 +@688 := (hB : @506) -> + (hfn : @537) -> + (hwt : @658) -> + (hbind : @666) -> + (hF : @634) -> + (hA : @669) -> + (hne : @296 @670 @301) -> @386 (fun (ro : @385) => @387 (@637 (@271 @320) @17) (@517 @567 @17)) +@689 := @657 @95 +@690 := @265 @538 +@698 := @355 (@541 @256 @66) (@363 (@67 (@64 @228) @66)) +@699 := @513 @590 +@700 := @271 @129 +@718 := (hfn : @537) -> + (hwt : @690) -> + (hbind : @698) -> + (hF : @634) -> + (hA : @699 @700) -> + (hne : @296 @668 @301) -> @386 (fun (ro : @385) => @387 (@637 (@271 @141) @17) (@517 @603 @17)) +@719 := Eq.refl.{1} +@722 := @689 (@719 @329 @507) +@723 := @269 @538 +@731 := @355 (@541 @264 @66) (@363 (@67 (@64 @243) @66)) +@732 := @513 @248 +@733 := @271 @131 +@749 := (hwt : @723) -> + (hbind : @731) -> + (hF : @634) -> + (hA : @732 @733) -> + (hne : @296 @700 @301) -> @386 (fun (ro : @385) => @387 (@637 @670 @17) (@517 @560 @17)) +@750 := @722 @268 +@752 := @541 @56 @66 +@755 := @355 @752 (@363 @69) +@756 := @513 @256 +@757 := @271 @12 +@772 := (hbind : @755) -> + (hF : @634) -> + (hA : @756 @757) -> + (hne : @296 @733 @301) -> @386 (fun (ro : @385) => @387 (@637 @668 @17) (@517 @555 @17)) +@775 := @750 (@719 @354 @752) +@776 := @513 @264 +@777 := @271 @14 +@791 := (hF : @634) -> + (hA : @776 @777) -> + (hne : @296 @757 @301) -> @386 (fun (ro : @385) => @387 (@637 @700 @17) (@517 @590 @17)) +@794 := @775 (@719 @366 @510) +@808 := (hA : @513 @56 @272) -> + (hne : @296 @777 @301) -> @386 (fun (ro : @385) => @387 (@637 @733 @17) (@517 @248 @17)) +@809 := @794 @293 +@820 := (hne : @296 @272 @301) -> @386 (fun (ro : @385) => @387 (@637 @757 @17) (@517 @256 @17)) +@821 := @809 @313 +@827 := @387 (@637 @777 @17) (@517 @264 @17) +@829 := @386 (fun (ro : @385) => @827) +@831 := @386 (fun (__e_ro : @385) => @827) +@835 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@836 := (__e_hrep : @835) -> @831 +@837 := fun (__e_hrep : @835) => @821 +@838 := (x : @3) -> @836 +@839 := fun (x : @3) => @837 +\end{coremodule} +\end{lexlean} diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R8/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R8/Compose/RustStd.lean deleted file mode 100644 index ad3eaf042..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R8/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8 -import LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (s : Nat) (x : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat s), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.denote s x) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat s), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat s) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat x) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.root s x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R8/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R8/Compose/RustStd.lex.tex new file mode 100644 index 000000000..d61746492 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R8/Compose/RustStd.lex.tex @@ -0,0 +1,474 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8, + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd.root : @938 := @939 { + all: [LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd.program +@1 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd.krate +@2 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@63 := Prod.{0, 0} +@64 := @63 @3 +@65 := @64 @54 +@66 := 1 +@69 := Prod.mk.{0, 0} @3 @54 +@70 := @69 @66 +@71 := @70 @50 +@72 := 0 +@73 := @69 @72 +@74 := @73 @6 +@75 := @55 @65 +@76 := @56 @65 +@78 := @76 @74 @75 +@80 := @76 @71 @78 +@81 := Bool.true +@82 := LexLeanTarget.TargetSyntax.Function +@83 := LexLeanTarget.TargetSyntax.Program.functions +@84 := @83 @0 +@85 := LexLeanTarget.TargetSyntax.Ty +@86 := @55 @3 +@87 := @55 @85 +@88 := LexLeanTarget.TargetSyntax.Ty.unit +@89 := LexLeanTarget.TargetSyntax.Value.unit +@92 := LexLeanTarget.TargetSyntax.Expr.value @88 @89 +@97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 +@102 := List.getD.{0} @82 @84 @72 @97 +@106 := fun (__e_n : @3) => + LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd.root @17 @72 +@107 := LexLeanPreservation.Rust.WTL +@115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 +@117 := LexLeanPreservation.Rust.wtl_nil @0 +@118 := @107 @0 +@124 := {c : @9} -> {A : @10} -> @118 @15 @17 @57 @87 +@125 := @117 @1 +@126 := @118 @1 +@130 := {A : @10} -> @126 @17 @57 @87 +@131 := @125 @2 +@132 := @126 @2 +@133 := @132 @57 +@134 := @133 @87 +@135 := List.{0} +@136 := @135 @54 +@137 := @135 @85 +@138 := #6 +@139 := @11 @138 +@140 := #5 +@141 := @139 @140 +@142 := #4 +@145 := @141 @142 @12 @4 +@146 := #7 +@151 := @107 @146 @138 @140 @4 @15 +@152 := #8 +@155 := @107 @152 @146 @138 +@157 := @58 @140 @12 +@158 := @155 @157 +@159 := @56 @85 +@161 := @159 @142 @4 +@171 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @145) -> (hs : @151) -> @158 @161 +@173 := LexLeanPreservation.Rust.wtl_cons @0 +@193 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> + (h : @27 @140 @142 @12 @4) -> (hs : @118 @138 @140 @4 @15) -> @118 @146 @138 @157 @161 +@194 := @173 @1 +@210 := {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> (h : @36 @142 @12 @4) -> (hs : @126 @140 @4 @15) -> @126 @138 @157 @161 +@211 := @194 @2 +@213 := @43 @12 @4 +@215 := @132 @4 @15 +@223 := {v : @54} -> + {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @213) -> (hs : @215) -> @132 @157 @161 +@224 := @211 @50 +@225 := @5 @142 +@226 := @43 @225 +@227 := @226 @4 +@228 := @5 @138 +@229 := @58 @228 +@231 := @132 (@229 @12) +@237 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @227) -> (hs : @215) -> @231 @161 +@238 := @224 @7 +@239 := @5 @12 +@241 := @43 @239 @7 +@242 := @5 @140 +@243 := @58 @242 +@245 := @132 (@243 @12) +@246 := @159 @7 +@247 := @246 @4 +@252 := {vs : @136} -> {ts : @137} -> (h : @241) -> (hs : @215) -> @245 @247 +@253 := @238 @57 +@254 := @133 @15 +@255 := @58 @225 +@256 := @255 @57 +@261 := {ts : @137} -> (h : @49) -> (hs : @254) -> @132 @256 @247 +@262 := @253 @87 +@263 := @58 @239 +@264 := @263 @57 +@265 := @132 @264 +@266 := @246 @87 +@269 := (h : @53) -> (hs : @134) -> @265 @266 +@270 := @262 @51 +@271 := @61 @57 +@273 := @132 @271 @266 +@274 := (hs : @134) -> @273 +@275 := @270 @131 +@277 := @132 @60 @266 +@278 := @211 @6 +@280 := @43 @242 @4 +@281 := @5 @146 +@282 := @58 @281 +@290 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @280) -> (hs : @215) -> @132 (@282 @12) @161 +@291 := @278 @7 +@297 := {vs : @136} -> {ts : @137} -> (h : @226 @7) -> (hs : @215) -> @231 @247 +@298 := @291 @60 +@299 := @265 @15 +@300 := @243 @256 +@301 := @132 @300 +@305 := {ts : @137} -> (h : @241) -> (hs : @299) -> @301 @247 +@306 := @298 @266 +@307 := @255 @264 +@308 := @132 @307 +@309 := @246 @266 +@312 := (h : @49) -> (hs : @273) -> @308 @309 +@313 := @306 @47 +@314 := @263 @271 +@315 := @132 @314 +@317 := (hs : @277) -> @315 @309 +@318 := @313 @275 +@319 := @132 @62 +@320 := @319 @309 +@321 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.__fits_0 +@326 := @324 @4 @15 +@329 := Models.Main.flowStep @4 @15 +@330 := Bool +@332 := @63 @330 @330 +@335 := Except.{0, 0} @332 @3 +@336 := @64 @335 +@337 := LexLeanTarget.TargetSyntax.Value.bool +@338 := LexLeanPreservation.encPair +@342 := @338 @330 @330 @337 @337 +@344 := LexLeanPreservation.encExcept @332 +@347 := @344 @3 @342 @5 +@351 := @338 @3 @335 @5 @347 +@355 := @344 @336 @342 @351 @329 +@358 := LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.root @4 @15 +@359 := Ne.{1} +@360 := LexLeanPreservation.Obs +@361 := @359 @360 +@362 := LexLeanPreservation.Rel +@365 := @361 (@362 @15 @17) +@366 := LexLeanPreservation.Obs.stuck +@369 := (f : @330) -> (v : @54) -> @365 @366 +@371 := LexLeanPreservation.Rust.rel_ne_stuck @326 +@378 := (v : @54) -> @361 (@362 (@324 @12 @4) @17) @366 +@379 := @371 @355 +@383 := @361 (@362 @326 @355) @366 +@384 := @135 @65 +@385 := LexLeanPreservation.Rust.FunSem +@386 := #9 +@392 := (n : @3) -> @385 @386 @152 @146 @17 @138 +@393 := Eq.{1} +@394 := Option.{0} +@395 := @394 @82 +@396 := @393 @395 +@403 := LexLeanRuntime.index (@135 @82) @82 (LexLeanRuntime.instIndexableList @82) +@407 := @396 (@403 (@83 @386) @138) +@408 := Option.some.{0} +@409 := @408 @82 +@410 := @409 @140 +@411 := @407 @410 +@412 := #10 +@416 := @107 @412 @386 @152 @140 +@417 := LexLeanTarget.TargetSyntax.Function.types +@418 := @417 @138 +@419 := @416 @418 +@420 := @394 @384 +@421 := @393 @420 +@422 := LexLeanTarget.TargetSemantics.bindAll +@423 := LexLeanTarget.TargetSyntax.Function.parameters +@428 := @421 (@422 (@423 @146) @138 @75) +@429 := @408 @384 +@430 := @429 @140 +@431 := @428 @430 +@432 := @394 @330 +@433 := @393 @432 +@434 := LexLeanPreservation.Rust.fnFallible +@435 := #11 +@438 := @433 (@434 @435 @386) +@439 := @408 @330 +@440 := @439 @140 +@441 := @438 @440 +@442 := LexLeanPreservation.RunConv +@443 := #13 +@447 := @442 @443 @412 @152 @140 +@449 := @361 @138 @366 +@450 := Exists.{1} +@451 := LexLeanPreservation.Rust.ROut +@452 := @450 @451 +@453 := And +@454 := LexLeanPreservation.Rust.RealizesFn +@458 := @453 (@454 @386 @152 @17) +@459 := LexLeanPreservation.Rust.RCI +@461 := @459 #15 +@462 := LexLeanPreservation.Rust.fnIdent +@463 := @462 @443 +@470 := (hne : @449) -> @452 (fun (ro : @451) => @458 (@461 @463 @435 @17)) +@485 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @384} -> + {F : @330} -> + {o : @360} -> + (hB : @392) -> + (hfn : @411) -> (hwt : @419) -> (hbind : @431) -> (hF : @441) -> (hA : @447) -> @470 +@487 := LexLeanPreservation.Rust.compose @0 +@488 := @385 @0 +@493 := (n : @3) -> @488 @152 @146 @17 @138 +@494 := @403 @84 +@497 := @396 (@494 @138) @410 +@501 := @118 @386 @152 @140 @418 +@502 := @442 @0 +@505 := @502 @412 @152 @140 +@519 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @384} -> + {F : @330} -> + {o : @360} -> + (hB : @493) -> + (hfn : @497) -> (hwt : @501) -> (hbind : @431) -> (hF : @441) -> (hA : @505) -> @470 +@520 := @487 @1 +@521 := @488 @1 +@525 := (n : @3) -> @521 @146 @17 @138 +@528 := @126 @152 @140 @418 +@529 := @434 @1 +@532 := @433 (@529 @386) @440 +@533 := @459 @1 +@543 := (hbind : @431) -> + (hF : @532) -> (hA : @505) -> (hne : @449) -> @452 (fun (ro : @451) => @458 (@533 @463 @435 @17)) +@553 := {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @384} -> {F : @330} -> {o : @360} -> (hB : @525) -> (hfn : @497) -> (hwt : @528) -> @543 +@554 := @520 @2 +@556 := @521 @2 @17 +@558 := (n : @3) -> @556 @138 +@559 := @132 @140 +@560 := @559 @418 +@569 := {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @384} -> {F : @330} -> {o : @360} -> (hB : @558) -> (hfn : @497) -> (hwt : @560) -> @543 +@570 := @554 @72 +@572 := (n : @3) -> @556 @72 +@573 := @494 @72 +@574 := @396 @573 +@575 := @574 @410 +@576 := @529 @72 +@577 := @433 @576 +@578 := @577 @440 +@579 := @502 @72 +@581 := @579 @152 @140 +@583 := @533 (@462 @72) +@591 := (hF : @578) -> (hA : @581) -> (hne : @449) -> @452 (fun (ro : @451) => @458 (@583 @435 @17)) +@600 := {fn : @82} -> + {args : @136} -> + {env : @384} -> + {F : @330} -> {o : @360} -> (hB : @572) -> (hfn : @575) -> (hwt : @560) -> (hbind : @431) -> @591 +@601 := @570 @102 +@603 := @574 (@409 @102) +@604 := @417 @102 +@605 := @559 @604 +@607 := @422 (@423 @102) +@619 := {args : @136} -> + {env : @384} -> + {F : @330} -> + {o : @360} -> + (hB : @572) -> (hfn : @603) -> (hwt : @605) -> (hbind : @421 (@607 @138 @75) @430) -> @591 +@620 := @601 @62 +@622 := @282 (@229 @57) +@624 := @132 @622 @604 +@626 := @58 (@5 @152) +@628 := @626 (@282 @57) +@632 := @421 (@607 @628 @75) @430 +@634 := @58 (@5 @412) +@636 := @58 (@5 @386) +@638 := @634 (@636 @57) +@640 := @579 @638 @140 +@642 := @58 (@5 @443) +@645 := @58 (@5 #12) +@662 := {env : @384} -> + {F : @330} -> + {o : @360} -> + (hB : @572) -> + (hfn : @603) -> + (hwt : @624) -> + (hbind : @632) -> + (hF : @578) -> + (hA : @640) -> (hne : @449) -> @452 (fun (ro : @451) => @458 (@583 (@642 (@645 @57)) @17)) +@663 := @620 @80 +@665 := @229 (@243 @57) +@667 := @132 @665 @604 +@678 := @421 (@607 @622 @75) (@429 (@76 (@70 @228) (@76 (@73 @281) @75))) +@680 := @636 (@626 @57) +@682 := @579 @680 @140 +@684 := @58 (@5 @435) +@700 := {F : @330} -> + {o : @360} -> + (hB : @572) -> + (hfn : @603) -> + (hwt : @667) -> + (hbind : @678) -> + (hF : @578) -> + (hA : @682) -> (hne : @449) -> @452 (fun (ro : @451) => @458 (@583 (@645 (@684 @57)) @17)) +@701 := @663 @81 +@702 := @301 @604 +@713 := @421 (@607 @665 @75) (@429 (@76 (@70 @242) (@76 (@73 @228) @75))) +@715 := @577 (@439 @81) +@717 := @579 @628 @140 +@718 := @454 @81 +@736 := {o : @360} -> + (hB : @572) -> + (hfn : @603) -> + (hwt : @702) -> + (hbind : @713) -> + (hF : @715) -> + (hA : @717) -> + (hne : @449) -> @452 (fun (ro : @451) => @453 (@718 @152 @17) (@583 (@684 (@634 @57)) @17)) +@737 := @701 @323 +@738 := @308 @604 +@749 := @421 (@607 @300 @75) (@429 (@76 (@70 @225) (@76 (@73 @242) @75))) +@750 := @579 @622 +@752 := @321 @146 @138 +@753 := @750 @752 +@755 := @321 @152 @146 +@774 := (hB : @572) -> + (hfn : @603) -> + (hwt : @738) -> + (hbind : @749) -> + (hF : @715) -> + (hA : @753) -> + (hne : @361 @755 @366) -> + @452 (fun (ro : @451) => @453 (@718 (@321 @412 @386) @17) (@583 @638 @17)) +@775 := @737 @106 +@776 := @315 @604 +@787 := @421 (@607 @307 @75) (@429 (@76 (@70 @239) (@76 (@73 @225) @75))) +@788 := @579 @665 +@790 := @321 @138 @140 +@809 := (hfn : @603) -> + (hwt : @776) -> + (hbind : @787) -> + (hF : @715) -> + (hA : @788 @790) -> + (hne : @361 @752 @366) -> + @452 (fun (ro : @451) => @453 (@718 (@321 @386 @152) @17) (@583 @680 @17)) +@810 := Eq.refl.{1} +@813 := @775 (@810 @395 @573) +@814 := @319 @604 +@825 := @421 (@607 @314 @75) (@429 (@76 (@70 @6) (@76 (@73 @239) @75))) +@826 := @579 @300 +@828 := @321 @140 @142 +@844 := (hwt : @814) -> + (hbind : @825) -> + (hF : @715) -> + (hA : @826 @828) -> + (hne : @361 @790 @366) -> @452 (fun (ro : @451) => @453 (@718 @755 @17) (@583 @628 @17)) +@845 := @813 @318 +@847 := @607 @62 @75 +@850 := @421 @847 (@429 @80) +@851 := @579 @307 +@853 := @321 @142 @12 +@868 := (hbind : @850) -> + (hF : @715) -> + (hA : @851 @853) -> + (hne : @361 @828 @366) -> @452 (fun (ro : @451) => @453 (@718 @752 @17) (@583 @622 @17)) +@871 := @845 (@810 @420 @847) +@872 := @579 @314 +@874 := @321 @12 @4 +@888 := (hF : @715) -> + (hA : @872 @874) -> + (hne : @361 @853 @366) -> @452 (fun (ro : @451) => @453 (@718 @790 @17) (@583 @665 @17)) +@891 := @871 (@810 @432 @576) +@905 := (hA : @579 @62 @323) -> + (hne : @361 @874 @366) -> @452 (fun (ro : @451) => @453 (@718 @828 @17) (@583 @300 @17)) +@906 := @891 @358 +@917 := (hne : @361 @323 @366) -> @452 (fun (ro : @451) => @453 (@718 @853 @17) (@583 @307 @17)) +@918 := @906 @379 +@924 := @453 (@718 @874 @17) (@583 @314 @17) +@926 := @452 (fun (ro : @451) => @924) +@928 := @452 (fun (__e_ro : @451) => @924) +@933 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@934 := (__e_hrep : @933) -> @928 +@935 := fun (__e_hrep : @933) => @918 +@936 := (x : @3) -> @934 +@937 := fun (x : @3) => @935 +@938 := (s : @3) -> @936 +@939 := fun (s : @3) => @937 +\end{coremodule} +\end{lexlean} diff --git a/examples/models/expected/verify/preserve/audit.txt b/examples/models/expected/verify/preserve/audit.txt index 8f76a96dd..f0a0bc728 100644 --- a/examples/models/expected/verify/preserve/audit.txt +++ b/examples/models/expected/verify/preserve/audit.txt @@ -7800,6 +7800,12 @@ 'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.__wt_0' depends on axioms: [propext] -- statement vocabulary inductive LexLeanPreservation.Obs : Type number of parameters: 0 diff --git a/examples/models/expected/verify/preserve/preservation.json b/examples/models/expected/verify/preserve/preservation.json index 976d475a2..bf480ecb8 100644 --- a/examples/models/expected/verify/preserve/preservation.json +++ b/examples/models/expected/verify/preserve/preservation.json @@ -1 +1 @@ -{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":205391,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0","program":{"byte_length":81179,"sha256":"19c6696a115eee2945d9bc249774c91c5aa79a832ce10f52e67adb1a18bad77a"},"renderings":[{"byte_length":201067,"composed":{"byte_length":3064,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd","sha256":"d28ea567f7d62115d1fa28e6c1094741784808f88bf7a55c04fe7dc81142debd","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.root"},"crate":{"byte_length":29901,"sha256":"52b8e3b70d563369f42dfff8d391090bce768b71ed790f646aa9760fb4ec6d6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd","sha256":"222ff862f8dc5b1a45bc4ccd0ecd565d0f9c915494a68cf50e485ee2d650e5ce","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.root"}],"root":"Models.Main.classify","sha256":"eaae0334f0ba2f7fc6560acb15a15838f92dd63a1b51274a8f4be97d93b48050","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.root"},{"byte_length":215569,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1","program":{"byte_length":83992,"sha256":"dce1e094aa452ad9f91b8784cdd0b834f9d69ea208e937eea7aa7d24c0c2addb"},"renderings":[{"byte_length":208269,"composed":{"byte_length":3064,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd","sha256":"63ea278963a26878bad3d4aec8cd52c2d3e1dcc7aef4a2cc1a0ab27400c05144","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.root"},"crate":{"byte_length":30770,"sha256":"67121441756174b7f9423e6843041eea64787ce77aa9dcb6762bd775fd74881e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd","sha256":"dba3e6f5fcbed74c1f04fd2166e702e23cad61cab4ba0011641cb44db2f7f8b2","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.root"}],"root":"Models.Main.classifyChecked","sha256":"0fa59dcbb3fd94e0a81f39df98f80a6c1396d05d9235743d9a1c3c44a3e861fa","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.root"},{"byte_length":86246,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2","program":{"byte_length":26060,"sha256":"09ddae4f092ac53b13ff3761c53a1371557124c89d6961d20261654bc4b1bdd9"},"renderings":[{"byte_length":84448,"composed":{"byte_length":3700,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd","sha256":"67847dee8806eaba2ca54af5bf508effff32ee84285da751295e1fb53d288250","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.root"},"crate":{"byte_length":21425,"sha256":"f576dc3bf699ab120bb97fe7962cea4bf4f465cea6730924fea750d36285f2c5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd","sha256":"cf1877f29d329d0bb65245c75fbeff5bb534ce10de93832e54fc061c9e19d7e0","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.root"}],"root":"Models.Main.respond","sha256":"bca3dc1a3e277268971a8053a7f577e22a5faa1c6e15950ae1449e358771a856","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.root"},{"byte_length":41340,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3","program":{"byte_length":11441,"sha256":"5eb0b277acebe2fd4e4accd84aada754039021640f20e31e8a810623b617a840"},"renderings":[{"byte_length":42275,"composed":{"byte_length":2318,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd","sha256":"b00cf8cec6acdac069af30778db9946666390c87f044a82bbb4001bc28e159c8","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd.root"},"crate":{"byte_length":17019,"sha256":"5f186f5373dce90862c9a810e08bd13a8abf477bd797f8d5ec8716e8d63f652b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd","sha256":"09865f4a8a190d436a2e1dc4980aeacdd38ffa1105698505abf7dda8861e876d","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.root"}],"root":"Models.Main.admitCosts","sha256":"27545f6a177b8ef096853c7aabcdb16af90d9a78598b69715ab188aee5d1ecf9","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.root"},{"byte_length":16488,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4","program":{"byte_length":4260,"sha256":"36d1687bd2f49a8a4e634440ac23148a5f94ed7d3c5ec222fe66c0615e9208af"},"renderings":[{"byte_length":16667,"composed":{"byte_length":2450,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd","sha256":"0e53d7adb26f9e29a430f6fdc04a127b590f3db6f870373cebbbf5d78150aa5d","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.root"},"crate":{"byte_length":14275,"sha256":"9580e86941cdeea970dc62f25bbf63090547dd2dc3618a0a303a687147a8f2e8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd","sha256":"fe4b092d7d7f5a624cae0a5e712f6a805ec897bd009580fb930c11f7974e5e42","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.root"}],"root":"Models.Main.step","sha256":"e712ff10242e376d2e09efbdb4aaf9de4690e02825bb6f7ddb2bc6a5ffc81d93","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.root"},{"byte_length":16539,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5","program":{"byte_length":3912,"sha256":"223f35bd805c466609ba87317bb05b5d4c84e8ddb34eda0a212e475fa06ed6d0"},"renderings":[{"byte_length":13176,"composed":{"byte_length":1679,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd","sha256":"cfab7b7f5988ec2af2e4efb1f44983b308831cafa3f1f06b5abef2cd820b7cc9","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd.root"},"crate":{"byte_length":13783,"sha256":"e8382fdebcad23a5a1550fafd501fdb4e10d1fc1aefe4a8b2313567cf49a4f5c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd","sha256":"182735558e8809fbb4ef3d765a519bb23d79124b36ced109dc68b309980349d0","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd.root"}],"root":"Models.Main.ledgerPost","sha256":"c9a8c053d3ae3f478b466f8e687f0ee97772f6c9959bd270c28b7191de7e70a1","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.root"},{"byte_length":22235,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6","program":{"byte_length":4889,"sha256":"503bc027d950639ac5de5927de7fa4a04fca266c6fd0df3660196e5e287d7ce5"},"renderings":[{"byte_length":18749,"composed":{"byte_length":1679,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd","sha256":"3cd05642843a26363cf835078a8cd0e42643edee6df012ce96a585e7f7c40b9e","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd.root"},"crate":{"byte_length":14211,"sha256":"898563f8bae88021f224534c1354540b6a565545d6c7c6e0b6cddfd30fe6a429"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd","sha256":"9c4cb21103039f833a60915bbf161dcd88d9324d30fd04d904f6f5eafa7effbb","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd.root"}],"root":"Models.Main.ledgerFull","sha256":"1e2dfdd9a59dcc289e683c7868471d31aeba0061d1c3fb56ac37ad44965f11ab","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.root"},{"byte_length":11285,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7","program":{"byte_length":2614,"sha256":"8f1d418b689da95074ce318bd41caf146e0fc0c6e303165f2b1ca0abd385459d"},"renderings":[{"byte_length":8772,"composed":{"byte_length":1482,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd","sha256":"7f371f78bc4bbb257d1f14a1f70e413baa876b50382bf99c17318f9b3718c879","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd.root"},"crate":{"byte_length":13420,"sha256":"0250a47719d614ca1aac8b544aa0168a202e61e5eb0011f6aaff82e3e73e59dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd","sha256":"37b4b502b88ce36637c9c9b6509fb350d3950ed32fe91086617fdd7843835d65","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd.root"}],"root":"Models.Main.guessChecked","sha256":"60c01408719b503e1331c45e1d2fa541ab1e0ffe2ab3e4fd7264f20b95b85a91","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.root"},{"byte_length":28208,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8","program":{"byte_length":8003,"sha256":"61d87ac85673bcb778de069cf6923996eb9e821ad05d71bfde3d36dd1bb3d241"},"renderings":[{"byte_length":26659,"composed":{"byte_length":1679,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd","sha256":"18c93fe4409b4f8aca925c8780f6d00c6cac9b3c00b578d3f79075ab5ae279fd","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd.root"},"crate":{"byte_length":14939,"sha256":"e4f361765740eab4808750f5d31762757ae333d2e23d94047ba8761aeb607264"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd","sha256":"5365bc9dd06dc59f8f5eb9d13034fbe226a4b2bdf15313a8b7ef6d71f320b1e2","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd.root"}],"root":"Models.Main.flowStep","sha256":"b5941fdd04224511829eebde6232e033f404351d41ff3c82fa4929a874f03082","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":205391,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0","program":{"byte_length":81179,"sha256":"19c6696a115eee2945d9bc249774c91c5aa79a832ce10f52e67adb1a18bad77a"},"renderings":[{"byte_length":201067,"composed":{"byte_length":17234,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd","sha256":"ec0fa88fbdc139447a1babb3c7feab8a0cf60e7dee949694fcd27325c0daf76a","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.root"},"crate":{"byte_length":29901,"sha256":"52b8e3b70d563369f42dfff8d391090bce768b71ed790f646aa9760fb4ec6d6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd","sha256":"222ff862f8dc5b1a45bc4ccd0ecd565d0f9c915494a68cf50e485ee2d650e5ce","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.root"}],"root":"Models.Main.classify","sha256":"eaae0334f0ba2f7fc6560acb15a15838f92dd63a1b51274a8f4be97d93b48050","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.root"},{"byte_length":215569,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1","program":{"byte_length":83992,"sha256":"dce1e094aa452ad9f91b8784cdd0b834f9d69ea208e937eea7aa7d24c0c2addb"},"renderings":[{"byte_length":208269,"composed":{"byte_length":17449,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd","sha256":"0b1560e4dbc6ede5c8283b01ed64615bc99b306a6509652a9a55862910af6e21","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.root"},"crate":{"byte_length":30770,"sha256":"67121441756174b7f9423e6843041eea64787ce77aa9dcb6762bd775fd74881e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd","sha256":"dba3e6f5fcbed74c1f04fd2166e702e23cad61cab4ba0011641cb44db2f7f8b2","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.root"}],"root":"Models.Main.classifyChecked","sha256":"0fa59dcbb3fd94e0a81f39df98f80a6c1396d05d9235743d9a1c3c44a3e861fa","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.root"},{"byte_length":86246,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2","program":{"byte_length":26060,"sha256":"09ddae4f092ac53b13ff3761c53a1371557124c89d6961d20261654bc4b1bdd9"},"renderings":[{"byte_length":84448,"composed":{"byte_length":18513,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd","sha256":"2790135b57b653b7fcca6c0cd2ecf615aeda1a22f50ca2e7a4b7ff094cda4f08","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.root"},"crate":{"byte_length":21425,"sha256":"f576dc3bf699ab120bb97fe7962cea4bf4f465cea6730924fea750d36285f2c5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd","sha256":"cf1877f29d329d0bb65245c75fbeff5bb534ce10de93832e54fc061c9e19d7e0","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.root"}],"root":"Models.Main.respond","sha256":"bca3dc1a3e277268971a8053a7f577e22a5faa1c6e15950ae1449e358771a856","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.root"},{"byte_length":41340,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3","program":{"byte_length":11441,"sha256":"5eb0b277acebe2fd4e4accd84aada754039021640f20e31e8a810623b617a840"},"renderings":[{"byte_length":42275,"composed":{"byte_length":17868,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd","sha256":"4652bcedc3cf62c8a6056265eeb4fb2d0e97de2f1f0d575066c98d748b937f48","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd.root"},"crate":{"byte_length":17019,"sha256":"5f186f5373dce90862c9a810e08bd13a8abf477bd797f8d5ec8716e8d63f652b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd","sha256":"09865f4a8a190d436a2e1dc4980aeacdd38ffa1105698505abf7dda8861e876d","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.root"}],"root":"Models.Main.admitCosts","sha256":"27545f6a177b8ef096853c7aabcdb16af90d9a78598b69715ab188aee5d1ecf9","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.root"},{"byte_length":16488,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4","program":{"byte_length":4260,"sha256":"36d1687bd2f49a8a4e634440ac23148a5f94ed7d3c5ec222fe66c0615e9208af"},"renderings":[{"byte_length":16667,"composed":{"byte_length":17788,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd","sha256":"1c212928f0e55a46d9b77a991e7a31bfdef70c757573a1c0c599b8b6970fd4ae","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.root"},"crate":{"byte_length":14275,"sha256":"9580e86941cdeea970dc62f25bbf63090547dd2dc3618a0a303a687147a8f2e8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd","sha256":"fe4b092d7d7f5a624cae0a5e712f6a805ec897bd009580fb930c11f7974e5e42","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.root"}],"root":"Models.Main.step","sha256":"e712ff10242e376d2e09efbdb4aaf9de4690e02825bb6f7ddb2bc6a5ffc81d93","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.root"},{"byte_length":16539,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5","program":{"byte_length":3912,"sha256":"223f35bd805c466609ba87317bb05b5d4c84e8ddb34eda0a212e475fa06ed6d0"},"renderings":[{"byte_length":13176,"composed":{"byte_length":13445,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd","sha256":"2d59f4c082570005c699d7b10e8f5061c7969a87f8a527ca56e6c7d68a2f9d61","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd.root"},"crate":{"byte_length":13783,"sha256":"e8382fdebcad23a5a1550fafd501fdb4e10d1fc1aefe4a8b2313567cf49a4f5c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd","sha256":"182735558e8809fbb4ef3d765a519bb23d79124b36ced109dc68b309980349d0","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd.root"}],"root":"Models.Main.ledgerPost","sha256":"c9a8c053d3ae3f478b466f8e687f0ee97772f6c9959bd270c28b7191de7e70a1","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.root"},{"byte_length":22235,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6","program":{"byte_length":4889,"sha256":"503bc027d950639ac5de5927de7fa4a04fca266c6fd0df3660196e5e287d7ce5"},"renderings":[{"byte_length":18749,"composed":{"byte_length":13445,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd","sha256":"91eb81f62a7bf406c09553406893a8f3552490ee707638a97a457f558fdd4996","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd.root"},"crate":{"byte_length":14211,"sha256":"898563f8bae88021f224534c1354540b6a565545d6c7c6e0b6cddfd30fe6a429"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd","sha256":"9c4cb21103039f833a60915bbf161dcd88d9324d30fd04d904f6f5eafa7effbb","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd.root"}],"root":"Models.Main.ledgerFull","sha256":"1e2dfdd9a59dcc289e683c7868471d31aeba0061d1c3fb56ac37ad44965f11ab","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.root"},{"byte_length":11285,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7","program":{"byte_length":2614,"sha256":"8f1d418b689da95074ce318bd41caf146e0fc0c6e303165f2b1ca0abd385459d"},"renderings":[{"byte_length":8772,"composed":{"byte_length":12210,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd","sha256":"01c3676a450bbd9c255e496770d488421e64d7f7132e70968098277f0f91a647","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd.root"},"crate":{"byte_length":13420,"sha256":"0250a47719d614ca1aac8b544aa0168a202e61e5eb0011f6aaff82e3e73e59dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd","sha256":"37b4b502b88ce36637c9c9b6509fb350d3950ed32fe91086617fdd7843835d65","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd.root"}],"root":"Models.Main.guessChecked","sha256":"60c01408719b503e1331c45e1d2fa541ab1e0ffe2ab3e4fd7264f20b95b85a91","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.root"},{"byte_length":28208,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8","program":{"byte_length":8003,"sha256":"61d87ac85673bcb778de069cf6923996eb9e821ad05d71bfde3d36dd1bb3d241"},"renderings":[{"byte_length":26659,"composed":{"byte_length":13516,"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd","sha256":"48dfacd3e2464ef96a720451332742b42f4b2732dea55931ec4b44d006f3a9f9","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd.root"},"crate":{"byte_length":14939,"sha256":"e4f361765740eab4808750f5d31762757ae333d2e23d94047ba8761aeb607264"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd","sha256":"5365bc9dd06dc59f8f5eb9d13034fbe226a4b2bdf15313a8b7ef6d71f320b1e2","target":"rust-std","theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd.root"}],"root":"Models.Main.flowStep","sha256":"b5941fdd04224511829eebde6232e033f404351d41ff3c82fa4929a874f03082","targets":["rust-std"],"theorem":"LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.root"}],"spec":"lexlean/preservation/1"} diff --git a/examples/models/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/examples/models/expected/verify/process/preserve/LexLeanPreserve.Audit.json index 35a106236..0f4516f33 100644 --- a/examples/models/expected/verify/process/preserve/LexLeanPreserve.Audit.json +++ b/examples/models/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"bd93966c411a257fd1b258aebeb3ae0998f6a9e994fe38e1cfd4bdeac3ff5365","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R0.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R1.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R2.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R3.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R4.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"0386664a137c3538ecc449edf18c7406dfc1df3269808c0cd176003ad0ed9f82","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R0/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R0/Compose/RustStd.lean deleted file mode 100644 index 498c922f2..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R0/Compose/RustStd.lean +++ /dev/null @@ -1,50 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd - -mutual -theorem __wt_0 : ∀ (__v : (Coverage.Boundary.Grove)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__enc_0 __v) (.adt 0) - | Coverage.Boundary.Grove.node __x0 __x1 __x2 __x3 __x4 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat) __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_list (__wtItems_0 __x1)) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_string _root_.LexLeanPreservation.Rust.wt_int)) __x2) (_root_.LexLeanPreservation.Rust.wtl_cons (__wtAux_1 __x3) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_list (__wtItems_3 __x4)) _root_.LexLeanPreservation.Rust.wtl_nil))))) - | Coverage.Boundary.Grove.leaf __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_int)) __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - | Coverage.Boundary.Grove.settled __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wtAux_4 __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - -theorem __wtItems_0 : ∀ (__v : (List (Coverage.Boundary.Grove))), _root_.LexLeanPreservation.Rust.WTAll _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__items_0 __v) (.adt 0) - | [] => _root_.LexLeanPreservation.Rust.wtAll_nil - | __x0 :: __x1 => _root_.LexLeanPreservation.Rust.wtAll_cons (__wt_0 __x0) (__wtItems_0 __x1) - -theorem __wtAux_1 : ∀ (__v : (Option (Coverage.Boundary.Grove))), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__aux_1 __v) (.option (.adt 0)) - | none => _root_.LexLeanPreservation.Rust.wt_noneV - | some __x0 => _root_.LexLeanPreservation.Rust.wt_someV (__wt_0 __x0) - -theorem __wtAux_2 : ∀ (__v : (Prod Nat (Coverage.Boundary.Grove))), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__aux_2 __v) (.pair .nat (.adt 0)) - | (__x0, __x1) => _root_.LexLeanPreservation.Rust.wt_pairV (_root_.LexLeanPreservation.Rust.wt_nat __x0) (__wt_0 __x1) - -theorem __wtItems_3 : ∀ (__v : (List (Prod Nat (Coverage.Boundary.Grove)))), _root_.LexLeanPreservation.Rust.WTAll _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__items_3 __v) (.pair .nat (.adt 0)) - | [] => _root_.LexLeanPreservation.Rust.wtAll_nil - | __x0 :: __x1 => _root_.LexLeanPreservation.Rust.wtAll_cons (__wtAux_2 __x0) (__wtItems_3 __x1) - -theorem __wtAux_4 : ∀ (__v : (Except Nat (Coverage.Boundary.Grove))), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__aux_4 __v) (.result (.adt 0) .nat) - | Except.error __x0 => _root_.LexLeanPreservation.Rust.wt_errorV (_root_.LexLeanPreservation.Rust.wt_nat __x0) - | Except.ok __x0 => _root_.LexLeanPreservation.Rust.wt_okV (__wt_0 __x0) - -end - -theorem __wt_1 : ∀ (__s : (Coverage.Boundary.Ledger)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__enc_1 __s) (.adt 1) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_string _root_.LexLeanPreservation.Rust.wt_int)) (__s).entries) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_string (__s).owner) _root_.LexLeanPreservation.Rust.wtl_nil)) - -/-- The rendering of the root's entry, invoked on the encoded arguments, -realizes the encoded source result when the arguments satisfy §17.12's -invariants, and refuses them with `none` otherwise. -/ -theorem root (g : (Coverage.Boundary.Grove)) (ledger : (Coverage.Boundary.Ledger)) (picks : (Option (List Nat))) (spare : (List (List (Prod Nat Bool)))) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__enc_0 g), (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__enc_1 ledger), ((_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) picks), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool))) spare)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 18) [(_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__enc_0 g), (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__enc_1 ledger), ((_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat)) picks), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool))) spare)] __e_ro ∧ - (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.accepts g ledger picks spare → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.denote g ledger picks spare)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.accepts g ledger picks spare → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none) __e_ro) := - match _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.root __e_n 18) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 g) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_1 ledger) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encOption (_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat)) picks) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_bool))) spare) _root_.LexLeanPreservation.Rust.wtl_nil)))) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.entry g ledger picks spare) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) with - | ⟨__e_ro, __e_hr, __e_hc⟩ => ⟨__e_ro, __e_hc, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.entry_accepts g ledger picks spare __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.entry_refuses g ledger picks spare __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R0/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R0/Compose/RustStd.lex.tex new file mode 100644 index 000000000..f34b744b5 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R0/Compose/RustStd.lex.tex @@ -0,0 +1,1883 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wt_0 : @2059 := @2058 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtItems_0 : @2081 := @2080 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtItems_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_1 : @2103 := @2102 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtItems_3 : @2125 := @2124 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtItems_3], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_4 : @2147 := @2146 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_4], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_2 : @2169 := @2168 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wt_1 : @2176 := @2362 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.root : @3729 := @3730 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.flags +@3 := Coverage.Boundary.Grove +@4 := #0 +@5 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := fun (__v : @3) => @15 +@17 := List.{0} +@18 := @17 @3 +@19 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__items_0 +@20 := @19 @4 +@21 := LexLeanPreservation.Rust.WTAll +@22 := @21 @0 +@23 := @22 @1 +@24 := @23 @2 +@26 := @24 @20 @10 +@27 := fun (__v : @18) => @26 +@28 := Option.{0} +@29 := @28 @3 +@30 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__aux_1 +@31 := @30 @4 +@32 := LexLeanTarget.TargetSyntax.Ty.option +@33 := @32 @10 +@35 := @13 @31 @33 +@36 := fun (__v : @29) => @35 +@37 := Nat +@38 := Prod.{0, 0} +@39 := @38 @37 +@40 := @39 @3 +@41 := @17 @40 +@42 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__items_3 +@43 := @42 @4 +@44 := LexLeanTarget.TargetSyntax.Ty.nat +@45 := LexLeanTarget.TargetSyntax.Ty.pair +@46 := @45 @44 +@47 := @46 @10 +@49 := @24 @43 @47 +@50 := fun (__v : @41) => @49 +@53 := Except.{0, 0} @37 @3 +@54 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__aux_4 +@55 := @54 @4 +@56 := LexLeanTarget.TargetSyntax.Ty.result +@57 := @56 @10 +@58 := @57 @44 +@60 := @13 @55 @58 +@61 := fun (__v : @53) => @60 +@62 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__aux_2 +@65 := @13 (@62 @4) @47 +@66 := fun (__v : @40) => @65 +@67 := #7 +@68 := #6 +@69 := #2 +@70 := #5 +@71 := #4 +@72 := #1 +@73 := #3 +@74 := LexLeanTarget.TargetSyntax.Value.nat +@75 := LexLeanPreservation.encList +@76 := @75 @37 +@77 := @76 @74 +@78 := @77 @67 +@79 := LexLeanTarget.TargetSyntax.Ty.list +@80 := @79 @44 +@81 := LexLeanTarget.TargetSyntax.Program +@82 := LexLeanPreservation.Rust.RCrate +@83 := LexLeanPreservation.Rust.Flags +@86 := @7 @73 @69 @72 +@87 := @74 @4 +@93 := {p : @81} -> {c : @82} -> {A : @83} -> (n : @37) -> @86 @87 @44 +@95 := LexLeanPreservation.Rust.wt_nat @0 +@97 := @11 @69 @72 +@102 := {c : @82} -> {A : @83} -> (n : @37) -> @97 @87 @44 +@103 := @95 @1 +@104 := @12 @72 +@108 := {A : @83} -> (n : @37) -> @104 @87 @44 +@109 := @103 @2 +@110 := @13 @87 +@111 := @110 @44 +@112 := (n : @37) -> @111 +@113 := @109 @4 +@114 := fun (__x : @37) => @113 +@115 := Sort 1 +@116 := LexLeanTarget.TargetSyntax.Value +@117 := (a._@._internal._hyg.#0 : @4) -> @116 +@118 := LexLeanTarget.TargetSyntax.Ty +@121 := @7 @68 @70 @71 +@122 := @69 @4 +@125 := (x : @69) -> @121 @122 @72 +@126 := @17 @73 +@129 := @7 @67 @68 @70 +@132 := @75 @71 @73 @4 +@133 := @129 @132 +@134 := @79 @69 +@143 := {p : @81} -> + {c : @82} -> + {A : @83} -> {α : @115} -> {e : @117} -> {t : @118} -> (h : @125) -> (xs : @126) -> @133 @134 +@145 := LexLeanPreservation.Rust.wt_encList @0 +@147 := @11 @70 @71 +@150 := (x : @69) -> @147 @122 @72 +@152 := @11 @68 @70 +@161 := {c : @82} -> + {A : @83} -> {α : @115} -> {e : @117} -> {t : @118} -> (h : @150) -> (xs : @126) -> @152 @132 @134 +@162 := @145 @1 +@163 := @12 @71 +@166 := (x : @69) -> @163 @122 @72 +@167 := @12 @70 +@175 := {A : @83} -> + {α : @115} -> {e : @117} -> {t : @118} -> (h : @166) -> (xs : @126) -> @167 @132 @134 +@176 := @162 @2 +@178 := @13 @122 @72 +@179 := (x : @69) -> @178 +@186 := {α : @115} -> {e : @117} -> {t : @118} -> (h : @179) -> (xs : @126) -> @13 @132 @134 +@187 := @176 @37 +@188 := (a._@._internal._hyg.#0 : @37) -> @116 +@189 := (x : @37) -> @178 +@190 := @17 @37 +@198 := {e : @188} -> {t : @118} -> (h : @189) -> (xs : @190) -> @13 (@76 @73 @4) @134 +@199 := @187 @74 +@201 := (x : @37) -> @110 @72 +@203 := @13 (@77 @4) +@207 := {t : @118} -> (h : @201) -> (xs : @190) -> @203 @134 +@208 := @199 @44 +@209 := (x : @37) -> @111 +@210 := @203 @80 +@212 := (h : @209) -> (xs : @190) -> @210 +@213 := @208 @114 +@214 := @213 @67 +@216 := @13 @78 @80 +@217 := LexLeanPreservation.ListEnc.enc +@218 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__L_0 +@220 := @217 @3 @218 +@221 := @220 @68 +@222 := @79 @10 +@223 := @19 @68 +@224 := @17 @116 +@229 := @21 @71 @73 @69 @72 @4 +@232 := @7 @70 @71 @73 +@233 := LexLeanTarget.TargetSyntax.Value.list +@234 := @233 @69 +@235 := @232 @234 +@236 := @79 @72 +@243 := {p : @81} -> {c : @82} -> {A : @83} -> {vs : @224} -> {t : @118} -> (h : @229) -> @235 @236 +@245 := LexLeanPreservation.Rust.wt_list @0 +@249 := @22 @73 @69 @72 @4 +@251 := @11 @71 @73 +@258 := {c : @82} -> {A : @83} -> {vs : @224} -> {t : @118} -> (h : @249) -> @251 @234 @236 +@259 := @245 @1 +@262 := @23 @69 @72 @4 +@263 := @12 @73 +@269 := {A : @83} -> {vs : @224} -> {t : @118} -> (h : @262) -> @263 @234 @236 +@270 := @259 @2 +@277 := {vs : @224} -> {t : @118} -> (h : @24 @72 @4) -> @13 @234 @236 +@278 := @270 @223 +@279 := @19 @67 +@281 := @24 @279 @4 +@282 := #8 +@288 := {t : @118} -> (h : @281) -> @13 (@233 (@19 @282)) @236 +@289 := @278 @10 +@295 := (h : @24 @223 @10) -> @13 (@233 @279) @222 +@296 := @289 @69 +@299 := @13 (@233 @223) @222 +@300 := String +@301 := Int +@302 := @38 @300 +@303 := @302 @301 +@304 := LexLeanTarget.TargetSyntax.Value.string +@305 := LexLeanTarget.TargetSyntax.Value.int +@306 := LexLeanPreservation.encPair +@307 := @306 @300 +@308 := @307 @301 +@309 := @308 @304 +@310 := @309 @305 +@311 := @75 @303 +@312 := @311 @310 +@313 := @312 @70 +@314 := LexLeanTarget.TargetSyntax.Ty.string +@315 := LexLeanTarget.TargetSyntax.Ty.int +@316 := @45 @314 +@317 := @316 @315 +@318 := @79 @317 +@319 := @304 @4 +@325 := {p : @81} -> {c : @82} -> {A : @83} -> (s : @300) -> @86 @319 @314 +@327 := LexLeanPreservation.Rust.wt_string @0 +@332 := {c : @82} -> {A : @83} -> (s : @300) -> @97 @319 @314 +@333 := @327 @1 +@337 := {A : @83} -> (s : @300) -> @104 @319 @314 +@338 := @333 @2 +@339 := @13 @319 +@340 := @339 @314 +@341 := (s : @300) -> @340 +@343 := fun (__x : @300) => @338 @4 +@344 := @305 @4 +@350 := {p : @81} -> {c : @82} -> {A : @83} -> (n : @301) -> @86 @344 @315 +@352 := LexLeanPreservation.Rust.wt_int @0 +@357 := {c : @82} -> {A : @83} -> (n : @301) -> @97 @344 @315 +@358 := @352 @1 +@362 := {A : @83} -> (n : @301) -> @104 @344 @315 +@363 := @358 @2 +@364 := @13 @344 +@365 := @364 @315 +@366 := (n : @301) -> @365 +@368 := fun (__x : @301) => @363 @4 +@369 := (a._@._internal._hyg.#0 : @72) -> @116 +@370 := #9 +@373 := @7 @370 @282 @67 +@374 := @71 @4 +@377 := (x : @70) -> @373 @374 @69 +@378 := #10 +@384 := (x : @70) -> @7 @378 @370 @282 @374 @69 +@386 := @38 @67 @68 +@387 := #11 +@390 := @7 @387 @378 @370 +@395 := @306 @282 @67 @68 @70 @4 +@396 := @390 @395 +@398 := @45 @71 @73 +@411 := {p : @81} -> + {c : @82} -> + {A : @83} -> + {α : @115} -> + {β : @115} -> + {ea : @369} -> + {eb : @369} -> {s : @118} -> {t : @118} -> (ha : @377) -> (hb : @384) -> (x : @386) -> @396 @398 +@413 := LexLeanPreservation.Rust.wt_encPair @0 +@438 := {c : @82} -> + {A : @83} -> + {α : @115} -> + {β : @115} -> + {ea : @369} -> + {eb : @369} -> + {s : @118} -> + {t : @118} -> + (ha : (x : @70) -> @11 @282 @67 @374 @69) -> + (hb : (x : @70) -> @11 @370 @282 @374 @69) -> (x : @386) -> @11 @378 @370 @395 @398 +@439 := @413 @1 +@460 := {A : @83} -> + {α : @115} -> + {β : @115} -> + {ea : @369} -> + {eb : @369} -> + {s : @118} -> + {t : @118} -> + (ha : (x : @70) -> @12 @67 @374 @69) -> + (hb : (x : @70) -> @12 @282 @374 @69) -> (x : @386) -> @12 @370 @395 @398 +@461 := @439 @2 +@463 := @13 @374 @69 +@464 := (x : @70) -> @463 +@475 := {α : @115} -> + {β : @115} -> + {ea : @369} -> + {eb : @369} -> + {s : @118} -> {t : @118} -> (ha : @464) -> (hb : @464) -> (x : @386) -> @13 @395 @398 +@476 := @461 @300 +@477 := (a._@._internal._hyg.#0 : @300) -> @116 +@478 := (x : @300) -> @463 +@493 := {β : @115} -> + {ea : @477} -> + {eb : @369} -> + {s : @118} -> + {t : @118} -> (ha : @478) -> (hb : @464) -> (x : @302 @68) -> @13 (@307 @67 @68 @70 @4) @398 +@494 := @476 @301 +@495 := (a._@._internal._hyg.#0 : @301) -> @116 +@496 := (x : @301) -> @463 +@508 := {ea : @477} -> + {eb : @495} -> + {s : @118} -> {t : @118} -> (ha : @478) -> (hb : @496) -> (x : @303) -> @13 (@308 @68 @70 @4) @398 +@509 := @494 @304 +@511 := (x : @300) -> @339 @69 +@521 := {eb : @495} -> + {s : @118} -> {t : @118} -> (ha : @511) -> (hb : @496) -> (x : @303) -> @13 (@309 @70 @4) @398 +@522 := @509 @305 +@524 := (x : @301) -> @364 @69 +@526 := @13 (@310 @4) +@532 := {s : @118} -> {t : @118} -> (ha : @511) -> (hb : @524) -> (x : @303) -> @526 @398 +@533 := @522 @314 +@534 := (x : @300) -> @340 +@540 := {t : @118} -> (ha : @534) -> (hb : @524) -> (x : @303) -> @526 (@316 @73) +@541 := @533 @315 +@542 := (x : @301) -> @365 +@544 := (x : @303) -> @526 @317 +@546 := (ha : @534) -> (hb : @542) -> @544 +@550 := fun (__x : @303) => @541 @343 @368 @4 +@551 := @176 @303 +@552 := (a._@._internal._hyg.#0 : @303) -> @116 +@553 := (x : @303) -> @178 +@554 := @17 @303 +@562 := {e : @552} -> {t : @118} -> (h : @553) -> (xs : @554) -> @13 (@311 @73 @4) @134 +@563 := @551 @310 +@565 := (x : @303) -> @526 @72 +@567 := @13 (@312 @4) +@571 := {t : @118} -> (h : @565) -> (xs : @554) -> @567 @134 +@572 := @563 @317 +@575 := (h : @544) -> (xs : @554) -> @567 @318 +@576 := @572 @550 +@577 := @576 @70 +@579 := @13 @313 @318 +@580 := LexLeanPreservation.OptEnc.enc +@581 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__O_1 +@583 := @580 @3 @581 +@584 := @583 @71 +@585 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__L_3 +@587 := @217 @40 @585 +@588 := @587 @73 +@589 := @79 @47 +@590 := @42 @73 +@591 := @270 @590 +@592 := @42 @71 +@593 := @24 @592 +@594 := @593 @4 +@595 := @42 @70 +@600 := {t : @118} -> (h : @594) -> @13 (@233 @595) @236 +@601 := @591 @47 +@603 := @24 @590 @47 +@607 := (h : @603) -> @13 (@233 @592) @589 +@608 := @601 @4 +@611 := @13 (@233 @590) @589 +@612 := List.nil.{0} +@613 := List.cons.{0} +@614 := @612 @116 +@615 := @613 @116 +@617 := @615 @588 @614 +@619 := @615 @584 @617 +@621 := @615 @313 @619 +@623 := @615 @221 @621 +@625 := @615 @78 @623 +@626 := @612 @118 +@627 := @613 @118 +@628 := @627 @589 +@629 := @628 @626 +@630 := @627 @33 +@631 := @630 @629 +@632 := @627 @318 +@633 := @632 @631 +@634 := @627 @222 +@635 := @634 @633 +@636 := @627 @80 +@637 := @636 @635 +@638 := LexLeanPreservation.Rust.WTL +@646 := {p : @81} -> {c : @82} -> {A : @83} -> @638 @69 @72 @4 @614 @626 +@648 := LexLeanPreservation.Rust.wtl_nil @0 +@649 := @638 @0 +@655 := {c : @82} -> {A : @83} -> @649 @72 @4 @614 @626 +@656 := @648 @1 +@657 := @649 @1 +@661 := {A : @83} -> @657 @4 @614 @626 +@662 := @656 @2 +@663 := @657 @2 +@664 := @663 @614 +@665 := @664 @626 +@666 := @17 @118 +@667 := @121 @73 +@668 := @667 @69 +@673 := @638 @67 @68 @70 @69 @72 +@676 := @638 @282 @67 @68 +@678 := @615 @70 @73 +@679 := @676 @678 +@681 := @627 @71 @69 +@691 := {p : @81} -> + {c : @82} -> + {A : @83} -> + {v : @116} -> {t : @118} -> {vs : @224} -> {ts : @666} -> (h : @668) -> (hs : @673) -> @679 @681 +@693 := LexLeanPreservation.Rust.wtl_cons @0 +@694 := @147 @73 +@695 := @694 @69 +@699 := @649 @68 @70 @69 @72 +@711 := {c : @82} -> + {A : @83} -> + {v : @116} -> + {t : @118} -> {vs : @224} -> {ts : @666} -> (h : @695) -> (hs : @699) -> @649 @67 @68 @678 @681 +@712 := @693 @1 +@713 := @163 @73 +@714 := @713 @69 +@717 := @657 @70 @69 @72 +@727 := {A : @83} -> + {v : @116} -> + {t : @118} -> {vs : @224} -> {ts : @666} -> (h : @714) -> (hs : @717) -> @657 @68 @678 @681 +@728 := @712 @2 +@729 := @13 @73 +@730 := @729 @69 +@732 := @663 @69 @72 +@740 := {v : @116} -> + {t : @118} -> {vs : @224} -> {ts : @666} -> (h : @730) -> (hs : @732) -> @663 @678 @681 +@741 := @728 @588 +@742 := @587 @68 +@754 := {t : @118} -> + {vs : @224} -> + {ts : @666} -> (h : @13 @742 @69) -> (hs : @732) -> @663 (@615 (@587 @282) @73) @681 +@755 := @741 @589 +@756 := @587 @70 +@758 := @13 @756 @589 +@762 := @663 (@615 (@587 @67) @73) +@763 := @628 @69 +@768 := {vs : @224} -> {ts : @666} -> (h : @758) -> (hs : @732) -> @762 @763 +@769 := @755 @614 +@770 := @587 @71 +@772 := @13 @770 @589 +@773 := @664 @72 +@775 := @615 @742 @614 +@780 := {ts : @666} -> (h : @772) -> (hs : @773) -> @663 @775 @763 +@781 := @769 @626 +@783 := @13 @588 @589 +@785 := @615 @756 @614 +@786 := @663 @785 +@789 := (h : @783) -> (hs : @665) -> @786 @629 +@790 := @781 @608 +@792 := @615 @770 @614 +@794 := @663 @792 @629 +@795 := (hs : @665) -> @794 +@796 := @790 @662 +@798 := @663 @617 @629 +@799 := @728 @584 +@800 := @583 @67 +@812 := {t : @118} -> + {vs : @224} -> + {ts : @666} -> (h : @13 @800 @69) -> (hs : @732) -> @663 (@615 (@583 @370) @73) @681 +@813 := @799 @33 +@814 := @583 @68 +@816 := @13 @814 @33 +@820 := @663 (@615 (@583 @282) @73) +@821 := @630 @69 +@826 := {vs : @224} -> {ts : @666} -> (h : @816) -> (hs : @732) -> @820 @821 +@827 := @813 @617 +@828 := @583 @70 +@830 := @13 @828 @33 +@831 := @786 @72 +@833 := @615 @800 @775 +@838 := {ts : @666} -> (h : @830) -> (hs : @831) -> @663 @833 @821 +@839 := @827 @629 +@841 := @13 @584 @33 +@843 := @615 @814 @785 +@844 := @663 @843 +@847 := (h : @841) -> (hs : @794) -> @844 @631 +@848 := @839 @72 +@850 := @615 @828 @792 +@852 := @663 @850 @631 +@853 := (hs : @798) -> @852 +@854 := @848 @796 +@856 := @663 @619 @631 +@857 := @728 @313 +@858 := @312 @282 +@870 := {t : @118} -> + {vs : @224} -> + {ts : @666} -> (h : @13 @858 @69) -> (hs : @732) -> @663 (@615 (@312 @378) @73) @681 +@871 := @857 @318 +@872 := @312 @67 +@874 := @13 @872 @318 +@878 := @663 (@615 (@312 @370) @73) +@879 := @632 @69 +@884 := {vs : @224} -> {ts : @666} -> (h : @874) -> (hs : @732) -> @878 @879 +@885 := @871 @619 +@886 := @312 @68 +@888 := @13 @886 @318 +@889 := @844 @72 +@891 := @615 @858 @833 +@896 := {ts : @666} -> (h : @888) -> (hs : @889) -> @663 @891 @879 +@897 := @885 @631 +@899 := @615 @872 @843 +@900 := @663 @899 +@903 := (h : @579) -> (hs : @852) -> @900 @633 +@904 := @897 @577 +@906 := @615 @886 @850 +@908 := @663 @906 @633 +@909 := (hs : @856) -> @908 +@910 := @904 @854 +@912 := @663 @621 @633 +@913 := @728 @221 +@914 := @220 @370 +@926 := {t : @118} -> + {vs : @224} -> + {ts : @666} -> (h : @13 @914 @69) -> (hs : @732) -> @663 (@615 (@220 @387) @73) @681 +@927 := @913 @222 +@928 := @220 @282 +@930 := @13 @928 @222 +@934 := @663 (@615 (@220 @378) @73) +@935 := @634 @69 +@940 := {vs : @224} -> {ts : @666} -> (h : @930) -> (hs : @732) -> @934 @935 +@941 := @927 @621 +@942 := @220 @67 +@944 := @13 @942 @222 +@945 := @900 @72 +@947 := @615 @914 @891 +@952 := {ts : @666} -> (h : @944) -> (hs : @945) -> @663 @947 @935 +@953 := @941 @633 +@955 := @13 @221 @222 +@957 := @615 @928 @899 +@958 := @663 @957 +@961 := (h : @955) -> (hs : @908) -> @958 @635 +@962 := @953 @296 +@964 := @615 @942 @906 +@966 := @663 @964 @635 +@967 := (hs : @912) -> @966 +@968 := @962 @910 +@970 := @663 @623 @635 +@971 := @728 @78 +@972 := @77 @378 +@974 := @13 @972 @69 +@975 := #12 +@985 := {t : @118} -> + {vs : @224} -> {ts : @666} -> (h : @974) -> (hs : @732) -> @663 (@615 (@77 @975) @73) @681 +@986 := @971 @80 +@987 := @77 @370 +@989 := @13 @987 @80 +@993 := @663 (@615 (@77 @387) @73) +@994 := @636 @69 +@999 := {vs : @224} -> {ts : @666} -> (h : @989) -> (hs : @732) -> @993 @994 +@1000 := @986 @623 +@1001 := @77 @282 +@1003 := @13 @1001 @80 +@1004 := @958 @72 +@1006 := @615 @972 @947 +@1011 := {ts : @666} -> (h : @1003) -> (hs : @1004) -> @663 @1006 @994 +@1012 := @1000 @635 +@1014 := @615 @987 @957 +@1015 := @663 @1014 +@1018 := (h : @216) -> (hs : @966) -> @1015 @637 +@1019 := @1012 @214 +@1021 := @615 @1001 @964 +@1023 := @663 @1021 @637 +@1024 := (hs : @970) -> @1023 +@1025 := @1019 @968 +@1027 := @663 @625 @637 +@1028 := Eq.{1} +@1029 := @28 @666 +@1030 := @1028 @1029 +@1031 := LexLeanPreservation.Rust.adtFields +@1035 := @1030 (@1031 @68 @73 @69) +@1036 := Option.some.{0} +@1037 := @1036 @666 +@1038 := @1037 @4 +@1039 := @1035 @1038 +@1042 := @7 @282 @67 @68 +@1043 := LexLeanTarget.TargetSyntax.Value.adt +@1045 := @1043 @71 @73 +@1046 := @1042 @1045 +@1047 := @8 @70 +@1057 := {p : @81} -> + {c : @82} -> + {A : @83} -> + {i : @37} -> {k : @37} -> {fs : @224} -> {tys : @666} -> (h : @1039) -> (hf : @673) -> @1046 @1047 +@1059 := LexLeanPreservation.Rust.wt_adt @0 +@1060 := @1031 @0 +@1064 := @1030 (@1060 @73 @69) @1038 +@1066 := @11 @67 @68 +@1076 := {c : @82} -> + {A : @83} -> + {i : @37} -> + {k : @37} -> {fs : @224} -> {tys : @666} -> (h : @1064) -> (hf : @699) -> @1066 @1045 @1047 +@1077 := @1059 @1 +@1078 := @12 @68 +@1087 := {A : @83} -> + {i : @37} -> + {k : @37} -> {fs : @224} -> {tys : @666} -> (h : @1064) -> (hf : @717) -> @1078 @1045 @1047 +@1088 := @1077 @2 +@1089 := @13 @1045 +@1096 := {i : @37} -> + {k : @37} -> {fs : @224} -> {tys : @666} -> (h : @1064) -> (hf : @732) -> @1089 @1047 +@1097 := @1088 @9 +@1098 := @1060 @9 +@1107 := {k : @37} -> + {fs : @224} -> {tys : @666} -> (h : @1030 (@1098 @69) @1038) -> (hf : @732) -> @1089 @10 +@1108 := @1097 @9 +@1109 := @1098 @9 +@1110 := @1030 @1109 +@1111 := @1110 @1038 +@1112 := @1043 @9 +@1114 := @13 (@1112 @73) +@1119 := {fs : @224} -> {tys : @666} -> (h : @1111) -> (hf : @732) -> @1114 @10 +@1120 := @1108 @625 +@1127 := {tys : @666} -> (h : @1111) -> (hf : @1015 @72) -> @13 (@1112 @1006) @10 +@1128 := @1120 @637 +@1135 := (h : @1110 (@1037 @637)) -> (hf : @1023) -> @13 (@1112 @1014) @10 +@1136 := Eq.refl.{1} +@1137 := @1136 @1029 +@1139 := @1128 (@1137 @1109) +@1143 := (hf : @1027) -> @13 (@1112 @1021) @10 +@1144 := @1139 @1025 +@1147 := @13 (@1112 @625) @10 +@1148 := @42 @69 +@1150 := @24 @1148 @47 +@1151 := fun (__ih2 : @1150) => @1144 +@1155 := fun (__ih1 : @13 (@30 @69) @33) => @1151 +@1156 := @19 @73 +@1158 := @24 @1156 @10 +@1164 := fun (__x0 : @190) => + fun (__x1 : @18) => + fun (__x2 : @554) => fun (__x3 : @29) => fun (__x4 : @41) => fun (__ih0 : @1158) => @1155 +@1165 := @39 @301 +@1166 := @306 @37 +@1167 := @1166 @301 +@1168 := @1167 @74 +@1169 := @1168 @305 +@1170 := @75 @1165 +@1171 := @1170 @1169 +@1172 := @1171 @4 +@1173 := @46 @315 +@1174 := @79 @1173 +@1175 := @461 @37 +@1176 := (x : @37) -> @463 +@1191 := {β : @115} -> + {ea : @188} -> + {eb : @369} -> + {s : @118} -> + {t : @118} -> (ha : @1176) -> (hb : @464) -> (x : @39 @68) -> @13 (@1166 @67 @68 @70 @4) @398 +@1192 := @1175 @301 +@1204 := {ea : @188} -> + {eb : @495} -> + {s : @118} -> + {t : @118} -> (ha : @1176) -> (hb : @496) -> (x : @1165) -> @13 (@1167 @68 @70 @4) @398 +@1205 := @1192 @74 +@1207 := (x : @37) -> @110 @69 +@1217 := {eb : @495} -> + {s : @118} -> {t : @118} -> (ha : @1207) -> (hb : @496) -> (x : @1165) -> @13 (@1168 @70 @4) @398 +@1218 := @1205 @305 +@1220 := @13 (@1169 @4) +@1226 := {s : @118} -> {t : @118} -> (ha : @1207) -> (hb : @524) -> (x : @1165) -> @1220 @398 +@1227 := @1218 @44 +@1228 := @46 @73 +@1233 := {t : @118} -> (ha : @209) -> (hb : @524) -> (x : @1165) -> @1220 @1228 +@1234 := @1227 @315 +@1236 := (x : @1165) -> @1220 @1173 +@1238 := (ha : @209) -> (hb : @542) -> @1236 +@1242 := fun (__x : @1165) => @1234 @114 @368 @4 +@1243 := @176 @1165 +@1244 := (a._@._internal._hyg.#0 : @1165) -> @116 +@1245 := (x : @1165) -> @178 +@1246 := @17 @1165 +@1254 := {e : @1244} -> {t : @118} -> (h : @1245) -> (xs : @1246) -> @13 (@1170 @73 @4) @134 +@1255 := @1243 @1169 +@1257 := (x : @1165) -> @1220 @72 +@1258 := @13 @1172 +@1262 := {t : @118} -> (h : @1257) -> (xs : @1246) -> @1258 @134 +@1263 := @1255 @1173 +@1264 := @1258 @1174 +@1266 := (h : @1236) -> (xs : @1246) -> @1264 +@1268 := @1263 @1242 @4 +@1270 := @615 @1172 @614 +@1271 := @627 @1174 +@1272 := @1271 @626 +@1273 := @728 @1172 +@1274 := @1171 @73 +@1286 := {t : @118} -> + {vs : @224} -> + {ts : @666} -> (h : @13 @1274 @69) -> (hs : @732) -> @663 (@615 (@1171 @70) @73) @681 +@1287 := @1273 @1174 +@1288 := @1171 @69 +@1290 := @13 @1288 @1174 +@1294 := @663 (@615 (@1171 @71) @73) +@1295 := @1271 @69 +@1300 := {vs : @224} -> {ts : @666} -> (h : @1290) -> (hs : @732) -> @1294 @1295 +@1301 := @1287 @614 +@1302 := @1171 @72 +@1304 := @13 @1302 @1174 +@1306 := @615 @1274 @614 +@1311 := {ts : @666} -> (h : @1304) -> (hs : @773) -> @663 @1306 @1295 +@1312 := @1301 @626 +@1314 := @615 @1288 @614 +@1315 := @663 @1314 +@1318 := (h : @1264) -> (hs : @665) -> @1315 @1272 +@1319 := @1312 @1268 +@1321 := @615 @1302 @614 +@1323 := @663 @1321 @1272 +@1324 := (hs : @665) -> @1323 +@1325 := @1319 @662 +@1327 := @663 @1270 @1272 +@1328 := 1 +@1329 := @1097 @1328 +@1330 := @1098 @1328 +@1331 := @1030 @1330 +@1332 := @1331 @1038 +@1333 := @1043 @1328 +@1340 := {fs : @224} -> {tys : @666} -> (h : @1332) -> (hf : @732) -> @13 (@1333 @73) @10 +@1341 := @1329 @1270 +@1348 := {tys : @666} -> (h : @1332) -> (hf : @1315 @72) -> @13 (@1333 @1306) @10 +@1349 := @1341 @1272 +@1356 := (h : @1331 (@1037 @1272)) -> (hf : @1323) -> @13 (@1333 @1314) @10 +@1358 := @1349 (@1137 @1330) +@1362 := (hf : @1327) -> @13 (@1333 @1321) @10 +@1363 := @1358 @1325 +@1366 := @13 (@1333 @1270) @10 +@1367 := fun (__x0 : @1246) => @1363 +@1368 := @54 @72 +@1370 := @615 @1368 @614 +@1371 := @627 @58 +@1372 := @1371 @626 +@1373 := @728 @1368 +@1374 := @54 @71 +@1386 := {t : @118} -> + {vs : @224} -> {ts : @666} -> (h : @13 @1374 @69) -> (hs : @732) -> @663 (@615 (@54 @68) @73) @681 +@1387 := @1373 @58 +@1388 := @54 @73 +@1390 := @13 @1388 @58 +@1394 := @663 (@615 (@54 @70) @73) +@1395 := @1371 @69 +@1400 := {vs : @224} -> {ts : @666} -> (h : @1390) -> (hs : @732) -> @1394 @1395 +@1401 := @1387 @614 +@1402 := @54 @69 +@1404 := @13 @1402 @58 +@1406 := @615 @1374 @614 +@1411 := {ts : @666} -> (h : @1404) -> (hs : @773) -> @663 @1406 @1395 +@1412 := @1401 @626 +@1414 := @13 @1368 @58 +@1416 := @615 @1388 @614 +@1417 := @663 @1416 +@1420 := (h : @1414) -> (hs : @665) -> @1417 @1372 +@1421 := @1412 @4 +@1423 := @615 @1402 @614 +@1425 := @663 @1423 @1372 +@1426 := (hs : @665) -> @1425 +@1427 := @1421 @662 +@1429 := @663 @1370 @1372 +@1430 := 2 +@1431 := @1097 @1430 +@1432 := @1098 @1430 +@1433 := @1030 @1432 +@1434 := @1433 @1038 +@1435 := @1043 @1430 +@1442 := {fs : @224} -> {tys : @666} -> (h : @1434) -> (hf : @732) -> @13 (@1435 @73) @10 +@1443 := @1431 @1370 +@1450 := {tys : @666} -> (h : @1434) -> (hf : @1417 @72) -> @13 (@1435 @1406) @10 +@1451 := @1443 @1372 +@1458 := (h : @1433 (@1037 @1372)) -> (hf : @1425) -> @13 (@1435 @1416) @10 +@1460 := @1451 (@1137 @1432) +@1464 := (hf : @1429) -> @13 (@1435 @1423) @10 +@1465 := @1460 @1427 +@1468 := @13 (@1435 @1370) @10 +@1470 := fun (__x0 : @53) => fun (__ih0 : @60) => @1465 +@1479 := {p : @81} -> {c : @82} -> {A : @83} -> {t : @118} -> @21 @73 @69 @72 @614 @4 +@1481 := LexLeanPreservation.Rust.wtAll_nil @0 +@1488 := {c : @82} -> {A : @83} -> {t : @118} -> @22 @69 @72 @614 @4 +@1489 := @1481 @1 +@1494 := {A : @83} -> {t : @118} -> @23 @72 @614 @4 +@1495 := @1489 @2 +@1496 := @24 @614 +@1498 := {t : @118} -> @1496 @4 +@1499 := @1495 @10 +@1500 := @1496 @10 +@1501 := @5 @73 +@1502 := @19 @69 +@1503 := @232 @69 +@1504 := @1503 @4 +@1509 := @21 @68 @70 @71 @69 @72 +@1512 := @21 @67 @68 @70 +@1514 := @615 @71 @73 +@1524 := {p : @81} -> + {c : @82} -> + {A : @83} -> + {v : @116} -> {vs : @224} -> {t : @118} -> (h : @1504) -> (hs : @1509) -> @1512 @1514 @69 +@1526 := LexLeanPreservation.Rust.wtAll_cons @0 +@1527 := @251 @69 +@1528 := @1527 @4 +@1543 := {c : @82} -> + {A : @83} -> + {v : @116} -> + {vs : @224} -> {t : @118} -> (h : @1528) -> (hs : @22 @70 @71 @69 @72) -> @22 @68 @70 @1514 @69 +@1544 := @1526 @1 +@1545 := @263 @69 +@1546 := @1545 @4 +@1558 := {A : @83} -> + {v : @116} -> + {vs : @224} -> {t : @118} -> (h : @1546) -> (hs : @23 @71 @69 @72) -> @23 @70 @1514 @69 +@1559 := @1544 @2 +@1560 := @13 @69 +@1561 := @1560 @4 +@1563 := @24 @69 @72 +@1570 := {v : @116} -> {vs : @224} -> {t : @118} -> (h : @1561) -> (hs : @1563) -> @24 @1514 @69 +@1571 := @1559 @1501 +@1572 := @5 @70 +@1573 := @13 @1572 +@1574 := @1573 @4 +@1575 := @5 @67 +@1576 := @615 @1575 +@1583 := {vs : @224} -> {t : @118} -> (h : @1574) -> (hs : @1563) -> @24 (@1576 @73) @69 +@1584 := @1571 @1502 +@1585 := @5 @71 +@1586 := @13 @1585 +@1587 := @1586 @4 +@1588 := @19 @71 +@1590 := @24 @1588 @72 +@1591 := @5 @68 +@1592 := @615 @1591 +@1599 := {t : @118} -> (h : @1587) -> (hs : @1590) -> @24 (@1592 (@19 @70)) @69 +@1600 := @1584 @10 +@1601 := @13 @1501 +@1602 := @1601 @10 +@1603 := @615 @1572 +@1608 := (h : @1602) -> (hs : @1158) -> @24 (@1603 @1588) @10 +@1609 := @1600 @72 +@1611 := @24 @1502 @10 +@1612 := @615 @1585 +@1616 := (hs : @1611) -> @24 (@1612 @1156) @10 +@1617 := @1609 @4 +@1618 := @615 @1501 +@1621 := @24 (@1618 @1502) @10 +@1625 := fun (__ih1 : @24 (@19 @72) @10) => @1617 +@1626 := @5 @72 +@1628 := @13 @1626 @10 +@1631 := fun (__x0 : @3) => fun (__x1 : @18) => fun (__ih0 : @1628) => @1625 +@1632 := LexLeanTarget.TargetSyntax.Value.none +@1633 := @86 @1632 +@1634 := @32 @4 +@1639 := {p : @81} -> {c : @82} -> {A : @83} -> {t : @118} -> @1633 @1634 +@1641 := LexLeanPreservation.Rust.wt_noneV @0 +@1646 := {c : @82} -> {A : @83} -> {t : @118} -> @97 @1632 @1634 +@1647 := @1641 @1 +@1651 := {A : @83} -> {t : @118} -> @104 @1632 @1634 +@1652 := @1647 @2 +@1653 := @13 @1632 +@1655 := {t : @118} -> @1653 @1634 +@1656 := @1652 @10 +@1657 := @1653 @33 +@1662 := @7 @71 @73 @69 @72 @4 +@1663 := LexLeanTarget.TargetSyntax.Value.some +@1664 := @1663 @69 +@1665 := @232 @1664 +@1666 := @32 @72 +@1673 := {p : @81} -> + {c : @82} -> {A : @83} -> {v : @116} -> {t : @118} -> (h : @1662) -> @1665 @1666 +@1675 := LexLeanPreservation.Rust.wt_someV @0 +@1686 := {c : @82} -> + {A : @83} -> {v : @116} -> {t : @118} -> (h : @11 @73 @69 @72 @4) -> @251 @1664 @1666 +@1687 := @1675 @1 +@1696 := {A : @83} -> {v : @116} -> {t : @118} -> (h : @12 @69 @72 @4) -> @263 @1664 @1666 +@1697 := @1687 @2 +@1704 := {v : @116} -> {t : @118} -> (h : @13 @72 @4) -> @13 @1664 @1666 +@1705 := @1697 @1626 +@1706 := @5 @69 +@1707 := @13 @1706 +@1713 := {t : @118} -> (h : @1707 @4) -> @13 (@1663 @1501) @1666 +@1714 := @1705 @10 +@1718 := (h : @1628) -> @13 (@1663 @1706) @33 +@1719 := @1714 @4 +@1722 := @13 (@1663 @1626) @33 +@1724 := fun (__x0 : @3) => fun (__ih0 : @15) => @1719 +@1725 := @1495 @47 +@1726 := @1496 @47 +@1727 := @62 @73 +@1728 := @1559 @1727 +@1729 := @62 @70 +@1740 := {vs : @224} -> + {t : @118} -> (h : @13 @1729 @4) -> (hs : @1563) -> @24 (@615 (@62 @67) @73) @69 +@1741 := @1728 @1148 +@1742 := @62 @71 +@1753 := {t : @118} -> (h : @13 @1742 @4) -> (hs : @593 @72) -> @24 (@615 (@62 @68) @595) @69 +@1754 := @1741 @47 +@1762 := (h : @13 @1727 @47) -> (hs : @603) -> @24 (@615 @1729 @592) @47 +@1763 := @1754 @72 +@1768 := (hs : @1150) -> @24 (@615 @1742 @590) @47 +@1769 := @1763 @4 +@1773 := @24 (@615 @1727 @1148) @47 +@1777 := fun (__ih1 : @24 (@42 @72) @47) => @1769 +@1783 := fun (__x0 : @40) => fun (__x1 : @41) => fun (__ih0 : @13 (@62 @72) @47) => @1777 +@1784 := LexLeanTarget.TargetSyntax.Value.error +@1785 := @1784 @73 +@1786 := @121 @1785 +@1788 := @56 @69 @72 +@1796 := {p : @81} -> + {c : @82} -> {A : @83} -> {v : @116} -> {s : @118} -> {t : @118} -> (h : @1504) -> @1786 @1788 +@1798 := LexLeanPreservation.Rust.wt_errorV @0 +@1806 := {c : @82} -> + {A : @83} -> {v : @116} -> {s : @118} -> {t : @118} -> (h : @1528) -> @147 @1785 @1788 +@1807 := @1798 @1 +@1814 := {A : @83} -> {v : @116} -> {s : @118} -> {t : @118} -> (h : @1546) -> @163 @1785 @1788 +@1815 := @1807 @2 +@1821 := {v : @116} -> {s : @118} -> {t : @118} -> (h : @1561) -> @13 @1785 @1788 +@1822 := @1815 @87 +@1823 := @74 @69 +@1824 := @13 @1823 +@1825 := @1824 @4 +@1826 := @74 @73 +@1832 := {s : @118} -> {t : @118} -> (h : @1825) -> @13 (@1784 @1826) @1788 +@1833 := @1822 @10 +@1834 := @74 @72 +@1836 := @13 @1834 @4 +@1838 := @13 (@1784 @1823) +@1839 := @57 @72 +@1842 := {t : @118} -> (h : @1836) -> @1838 @1839 +@1843 := @1833 @44 +@1847 := (h : @111) -> @13 (@1784 @1834) @58 +@1848 := @1843 @113 +@1851 := @13 (@1784 @87) @58 +@1852 := fun (__x0 : @37) => @1848 +@1853 := @1503 @72 +@1854 := LexLeanTarget.TargetSyntax.Value.ok +@1855 := @1854 @73 +@1864 := {p : @81} -> + {c : @82} -> + {A : @83} -> {v : @116} -> {s : @118} -> {t : @118} -> (h : @1853) -> @121 @1855 @1788 +@1866 := LexLeanPreservation.Rust.wt_okV @0 +@1875 := {c : @82} -> + {A : @83} -> {v : @116} -> {s : @118} -> {t : @118} -> (h : @1527 @72) -> @147 @1855 @1788 +@1876 := @1866 @1 +@1884 := {A : @83} -> {v : @116} -> {s : @118} -> {t : @118} -> (h : @1545 @72) -> @163 @1855 @1788 +@1885 := @1876 @2 +@1892 := {v : @116} -> {s : @118} -> {t : @118} -> (h : @1560 @72) -> @13 @1855 @1788 +@1893 := @1885 @1626 +@1894 := @1601 @72 +@1900 := {s : @118} -> {t : @118} -> (h : @1894) -> @13 (@1854 @1585) @1788 +@1901 := @1893 @10 +@1902 := @1707 @10 +@1907 := {t : @118} -> (h : @1902) -> @13 (@1854 @1501) @1839 +@1908 := @1901 @44 +@1912 := (h : @1628) -> @13 (@1854 @1706) @58 +@1913 := @1908 @4 +@1916 := @13 (@1854 @1626) @58 +@1918 := fun (__x0 : @3) => fun (__ih0 : @15) => @1913 +@1919 := @109 @69 +@1920 := @1824 @44 +@1921 := @667 @72 +@1923 := @129 @73 @72 +@1924 := LexLeanTarget.TargetSyntax.Value.pair +@1926 := @1924 @70 @71 +@1927 := @1042 @1926 +@1929 := @45 @73 @69 +@1939 := {p : @81} -> + {c : @82} -> + {A : @83} -> + {a : @116} -> + {b : @116} -> {s : @118} -> {t : @118} -> (ha : @1921) -> (hb : @1923) -> @1927 @1929 +@1941 := LexLeanPreservation.Rust.wt_pairV @0 +@1954 := {c : @82} -> + {A : @83} -> + {a : @116} -> + {b : @116} -> + {s : @118} -> {t : @118} -> (ha : @694 @72) -> (hb : @152 @73 @72) -> @1066 @1926 @1929 +@1955 := @1941 @1 +@1967 := {A : @83} -> + {a : @116} -> + {b : @116} -> + {s : @118} -> {t : @118} -> (ha : @713 @72) -> (hb : @167 @73 @72) -> @1078 @1926 @1929 +@1968 := @1955 @2 +@1969 := @729 @72 +@1977 := {a : @116} -> + {b : @116} -> {s : @118} -> {t : @118} -> (ha : @1969) -> (hb : @1969) -> @13 @1926 @1929 +@1978 := @1968 @1823 +@1979 := @74 @70 +@1991 := {b : @116} -> + {s : @118} -> + {t : @118} -> (ha : @13 @1979 @72) -> (hb : @1969) -> @13 (@1924 (@74 @67) @71) @1929 +@1992 := @1978 @1626 +@1993 := @74 @71 +@2005 := {s : @118} -> + {t : @118} -> (ha : @13 @1993 @72) -> (hb : @1586 @72) -> @13 (@1924 (@74 @68) @1572) @1929 +@2006 := @1992 @44 +@2016 := {t : @118} -> (ha : @13 @1826 @44) -> (hb : @1894) -> @13 (@1924 @1979 @1585) (@46 @69) +@2017 := @2006 @10 +@2023 := (ha : @1920) -> (hb : @1902) -> @13 (@1924 @1993 @1501) @47 +@2024 := @2017 @1919 +@2029 := (hb : @1628) -> @13 (@1924 @1826 @1706) @47 +@2030 := @2024 @4 +@2034 := @13 (@1924 @1823 @1626) @47 +@2037 := fun (__x0 : @37) => fun (__x1 : @3) => fun (__ih0 : @15) => @2030 +@2058 := fun (__v : @3) => + Coverage.Boundary.Grove.rec.{0} + @16 + @27 + @36 + @50 + @61 + @66 + @1164 + @1367 + @1470 + @1499 + @1631 + @1656 + @1724 + @1725 + @1783 + @1852 + @1918 + @2037 + @4 +@2059 := (__v : @3) -> @15 +@2080 := fun (__v : @18) => + Coverage.Boundary.Grove.rec_1.{0} + @16 + @27 + @36 + @50 + @61 + @66 + @1164 + @1367 + @1470 + @1499 + @1631 + @1656 + @1724 + @1725 + @1783 + @1852 + @1918 + @2037 + @4 +@2081 := (__v : @18) -> @26 +@2102 := fun (__v : @29) => + Coverage.Boundary.Grove.rec_2.{0} + @16 + @27 + @36 + @50 + @61 + @66 + @1164 + @1367 + @1470 + @1499 + @1631 + @1656 + @1724 + @1725 + @1783 + @1852 + @1918 + @2037 + @4 +@2103 := (__v : @29) -> @35 +@2124 := fun (__v : @41) => + Coverage.Boundary.Grove.rec_3.{0} + @16 + @27 + @36 + @50 + @61 + @66 + @1164 + @1367 + @1470 + @1499 + @1631 + @1656 + @1724 + @1725 + @1783 + @1852 + @1918 + @2037 + @4 +@2125 := (__v : @41) -> @49 +@2146 := fun (__v : @53) => + Coverage.Boundary.Grove.rec_4.{0} + @16 + @27 + @36 + @50 + @61 + @66 + @1164 + @1367 + @1470 + @1499 + @1631 + @1656 + @1724 + @1725 + @1783 + @1852 + @1918 + @2037 + @4 +@2147 := (__v : @53) -> @60 +@2168 := fun (__v : @40) => + Coverage.Boundary.Grove.rec_5.{0} + @16 + @27 + @36 + @50 + @61 + @66 + @1164 + @1367 + @1470 + @1499 + @1631 + @1656 + @1724 + @1725 + @1783 + @1852 + @1918 + @2037 + @4 +@2169 := (__v : @40) -> @65 +@2170 := Coverage.Boundary.Ledger +@2171 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.__enc_1 +@2172 := @2171 @4 +@2173 := @8 @1328 +@2176 := (__s : @2170) -> @13 @2172 @2173 +@2177 := Coverage.Boundary.Ledger.entries +@2178 := @2177 @4 +@2179 := Coverage.Boundary.Ledger.owner +@2180 := @2179 @4 +@2181 := @312 @2178 +@2182 := @576 @2178 +@2184 := @13 @2181 @318 +@2185 := @304 @2180 +@2186 := @338 @2180 +@2188 := @13 @2185 @314 +@2190 := @615 @2185 @614 +@2192 := @615 @2181 @2190 +@2193 := @627 @314 +@2194 := @2193 @626 +@2195 := @632 @2194 +@2196 := @728 @2185 +@2198 := @304 (@2179 @73) +@2211 := {t : @118} -> + {vs : @224} -> + {ts : @666} -> (h : @13 @2198 @69) -> (hs : @732) -> @663 (@615 (@304 (@2179 @70)) @73) @681 +@2212 := @2196 @314 +@2214 := @304 (@2179 @69) +@2216 := @13 @2214 @314 +@2221 := @663 (@615 (@304 (@2179 @71)) @73) +@2222 := @2193 @69 +@2227 := {vs : @224} -> {ts : @666} -> (h : @2216) -> (hs : @732) -> @2221 @2222 +@2228 := @2212 @614 +@2230 := @304 (@2179 @72) +@2232 := @13 @2230 @314 +@2234 := @615 @2198 @614 +@2239 := {ts : @666} -> (h : @2232) -> (hs : @773) -> @663 @2234 @2222 +@2240 := @2228 @626 +@2242 := @615 @2214 @614 +@2243 := @663 @2242 +@2246 := (h : @2188) -> (hs : @665) -> @2243 @2194 +@2247 := @2240 @2186 +@2249 := @615 @2230 @614 +@2251 := @663 @2249 @2194 +@2252 := (hs : @665) -> @2251 +@2253 := @2247 @662 +@2255 := @663 @2190 @2194 +@2256 := @728 @2181 +@2258 := @312 (@2177 @73) +@2271 := {t : @118} -> + {vs : @224} -> + {ts : @666} -> (h : @13 @2258 @69) -> (hs : @732) -> @663 (@615 (@312 (@2177 @70)) @73) @681 +@2272 := @2256 @318 +@2274 := @312 (@2177 @69) +@2286 := {vs : @224} -> + {ts : @666} -> (h : @13 @2274 @318) -> (hs : @732) -> @663 (@615 (@312 (@2177 @71)) @73) @879 +@2287 := @2272 @2190 +@2289 := @312 (@2177 @72) +@2291 := @13 @2289 @318 +@2292 := @2243 @72 +@2294 := @615 @2258 @2234 +@2299 := {ts : @666} -> (h : @2291) -> (hs : @2292) -> @663 @2294 @879 +@2300 := @2287 @2194 +@2302 := @615 @2274 @2242 +@2303 := @663 @2302 +@2306 := (h : @2184) -> (hs : @2251) -> @2303 @2195 +@2307 := @2300 @2182 +@2309 := @615 @2289 @2249 +@2311 := @663 @2309 @2195 +@2312 := (hs : @2255) -> @2311 +@2313 := @2307 @2253 +@2315 := @663 @2192 @2195 +@2316 := @1088 @1328 +@2317 := @1060 @1328 +@2326 := {k : @37} -> + {fs : @224} -> {tys : @666} -> (h : @1030 (@2317 @69) @1038) -> (hf : @732) -> @1089 @2173 +@2327 := @2316 @9 +@2328 := @2317 @9 +@2329 := @1030 @2328 +@2330 := @2329 @1038 +@2335 := {fs : @224} -> {tys : @666} -> (h : @2330) -> (hf : @732) -> @1114 @2173 +@2336 := @2327 @2192 +@2343 := {tys : @666} -> (h : @2330) -> (hf : @2303 @72) -> @13 (@1112 @2294) @2173 +@2344 := @2336 @2195 +@2351 := (h : @2329 (@1037 @2195)) -> (hf : @2311) -> @13 (@1112 @2302) @2173 +@2353 := @2344 (@1137 @2328) +@2357 := (hf : @2315) -> @13 (@1112 @2309) @2173 +@2358 := @2353 @2313 +@2361 := @13 (@1112 @2192) @2173 +@2362 := fun (__s : @2170) => @2358 +@2364 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wt_0 @71 +@2365 := @2171 @73 +@2367 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wt_1 @73 +@2368 := @28 @190 +@2369 := LexLeanPreservation.encOption +@2370 := @2369 @190 +@2371 := @2370 @77 +@2372 := @2371 @69 +@2373 := @32 @80 +@2375 := fun (__x : @190) => @213 @4 +@2376 := @28 @73 +@2379 := @2369 @71 @73 @4 +@2380 := @129 @2379 +@2381 := @32 @69 +@2390 := {p : @81} -> + {c : @82} -> + {A : @83} -> {α : @115} -> {e : @117} -> {t : @118} -> (h : @125) -> (o : @2376) -> @2380 @2381 +@2392 := LexLeanPreservation.Rust.wt_encOption @0 +@2401 := {c : @82} -> + {A : @83} -> + {α : @115} -> {e : @117} -> {t : @118} -> (h : @150) -> (o : @2376) -> @152 @2379 @2381 +@2402 := @2392 @1 +@2410 := {A : @83} -> + {α : @115} -> {e : @117} -> {t : @118} -> (h : @166) -> (o : @2376) -> @167 @2379 @2381 +@2411 := @2402 @2 +@2418 := {α : @115} -> {e : @117} -> {t : @118} -> (h : @179) -> (o : @2376) -> @13 @2379 @2381 +@2419 := @2411 @190 +@2429 := {e : (a._@._internal._hyg.#0 : @190) -> @116} -> + {t : @118} -> (h : (x : @190) -> @178) -> (o : @2368) -> @13 (@2370 @73 @4) @2381 +@2430 := @2419 @77 +@2432 := (x : @190) -> @203 @72 +@2434 := @13 (@2371 @4) +@2438 := {t : @118} -> (h : @2432) -> (o : @2368) -> @2434 @2381 +@2439 := @2430 @80 +@2443 := (h : (x : @190) -> @210) -> (o : @2368) -> @2434 @2373 +@2445 := @2439 @2375 @69 +@2447 := @13 @2372 @2373 +@2448 := Bool +@2449 := @39 @2448 +@2450 := @17 @2449 +@2451 := @17 @2450 +@2452 := LexLeanTarget.TargetSyntax.Value.bool +@2453 := @1166 @2448 +@2454 := @2453 @74 +@2455 := @2454 @2452 +@2456 := @75 @2449 +@2457 := @2456 @2455 +@2458 := @75 @2450 +@2459 := @2458 @2457 +@2460 := @2459 @72 +@2461 := LexLeanTarget.TargetSyntax.Ty.bool +@2462 := @46 @2461 +@2463 := @79 @2462 +@2464 := @79 @2463 +@2465 := @2452 @4 +@2471 := {p : @81} -> {c : @82} -> {A : @83} -> (b : @2448) -> @86 @2465 @2461 +@2473 := LexLeanPreservation.Rust.wt_bool @0 +@2478 := {c : @82} -> {A : @83} -> (b : @2448) -> @97 @2465 @2461 +@2479 := @2473 @1 +@2483 := {A : @83} -> (b : @2448) -> @104 @2465 @2461 +@2484 := @2479 @2 +@2485 := @13 @2465 +@2486 := @2485 @2461 +@2487 := (b : @2448) -> @2486 +@2489 := fun (__x : @2448) => @2484 @4 +@2490 := @1175 @2448 +@2491 := (a._@._internal._hyg.#0 : @2448) -> @116 +@2492 := (x : @2448) -> @463 +@2504 := {ea : @188} -> + {eb : @2491} -> + {s : @118} -> + {t : @118} -> (ha : @1176) -> (hb : @2492) -> (x : @2449) -> @13 (@2453 @68 @70 @4) @398 +@2505 := @2490 @74 +@2515 := {eb : @2491} -> + {s : @118} -> {t : @118} -> (ha : @1207) -> (hb : @2492) -> (x : @2449) -> @13 (@2454 @70 @4) @398 +@2516 := @2505 @2452 +@2518 := (x : @2448) -> @2485 @69 +@2520 := @13 (@2455 @4) +@2526 := {s : @118} -> {t : @118} -> (ha : @1207) -> (hb : @2518) -> (x : @2449) -> @2520 @398 +@2527 := @2516 @44 +@2532 := {t : @118} -> (ha : @209) -> (hb : @2518) -> (x : @2449) -> @2520 @1228 +@2533 := @2527 @2461 +@2534 := (x : @2448) -> @2486 +@2536 := (x : @2449) -> @2520 @2462 +@2538 := (ha : @209) -> (hb : @2534) -> @2536 +@2542 := fun (__x : @2449) => @2533 @114 @2489 @4 +@2543 := @176 @2449 +@2553 := {e : (a._@._internal._hyg.#0 : @2449) -> @116} -> + {t : @118} -> (h : (x : @2449) -> @178) -> (xs : @2450) -> @13 (@2456 @73 @4) @134 +@2554 := @2543 @2455 +@2556 := (x : @2449) -> @2520 @72 +@2558 := @13 (@2457 @4) +@2562 := {t : @118} -> (h : @2556) -> (xs : @2450) -> @2558 @134 +@2563 := @2554 @2462 +@2564 := @2558 @2463 +@2566 := (h : @2536) -> (xs : @2450) -> @2564 +@2569 := fun (__x : @2450) => @2563 @2542 @4 +@2570 := @176 @2450 +@2580 := {e : (a._@._internal._hyg.#0 : @2450) -> @116} -> + {t : @118} -> (h : (x : @2450) -> @178) -> (xs : @2451) -> @13 (@2458 @73 @4) @134 +@2581 := @2570 @2457 +@2583 := (x : @2450) -> @2558 @72 +@2584 := @2459 @4 +@2585 := @13 @2584 +@2589 := {t : @118} -> (h : @2583) -> (xs : @2451) -> @2585 @134 +@2590 := @2581 @2463 +@2594 := (h : (x : @2450) -> @2564) -> (xs : @2451) -> @2585 @2464 +@2596 := @2590 @2569 @72 +@2598 := @13 @2460 @2464 +@2600 := @615 @2460 @614 +@2602 := @615 @2372 @2600 +@2604 := @615 @2365 @2602 +@2605 := @1612 @2604 +@2606 := @39 @116 +@2607 := 3 +@2610 := Prod.mk.{0, 0} @37 @116 +@2611 := @2610 @2607 +@2612 := @2611 @2460 +@2613 := @2610 @1430 +@2614 := @2613 @2372 +@2615 := @2610 @1328 +@2616 := @2615 @2365 +@2617 := @2610 @9 +@2618 := @2617 @1585 +@2619 := @612 @2606 +@2620 := @613 @2606 +@2622 := @2620 @2618 @2619 +@2624 := @2620 @2616 @2622 +@2626 := @2620 @2614 @2624 +@2628 := @2620 @2612 @2626 +@2629 := Bool.false +@2630 := LexLeanTarget.TargetSyntax.Function +@2631 := LexLeanTarget.TargetSyntax.Program.functions +@2632 := @2631 @0 +@2633 := 18 +@2634 := @612 @37 +@2635 := LexLeanTarget.TargetSyntax.Ty.unit +@2636 := LexLeanTarget.TargetSyntax.Value.unit +@2639 := LexLeanTarget.TargetSyntax.Expr.value @2635 @2636 +@2644 := LexLeanTarget.TargetSyntax.Function.mk @2634 @626 @2635 @2639 +@2649 := List.getD.{0} @2630 @2632 @2633 @2644 +@2653 := fun (__e_n : @37) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.root @4 @2633 +@2654 := @728 @2460 +@2655 := @2459 @71 +@2657 := @13 @2655 @69 +@2658 := @2459 @68 +@2659 := @615 @2658 +@2667 := {t : @118} -> + {vs : @224} -> {ts : @666} -> (h : @2657) -> (hs : @732) -> @663 (@2659 @73) @681 +@2668 := @2654 @2464 +@2669 := @2459 @73 +@2671 := @13 @2669 @2464 +@2672 := @2459 @70 +@2673 := @615 @2672 +@2675 := @663 (@2673 @73) +@2676 := @627 @2464 +@2677 := @2676 @69 +@2682 := {vs : @224} -> {ts : @666} -> (h : @2671) -> (hs : @732) -> @2675 @2677 +@2683 := @2668 @614 +@2684 := @2459 @69 +@2686 := @13 @2684 @2464 +@2688 := @615 @2655 @614 +@2693 := {ts : @666} -> (h : @2686) -> (hs : @773) -> @663 @2688 @2677 +@2694 := @2683 @626 +@2696 := @615 @2669 @614 +@2697 := @663 @2696 +@2698 := @2676 @626 +@2701 := (h : @2598) -> (hs : @665) -> @2697 @2698 +@2702 := @2694 @2596 +@2704 := @615 @2684 @614 +@2706 := @663 @2704 @2698 +@2707 := (hs : @665) -> @2706 +@2708 := @2702 @662 +@2710 := @663 @2600 @2698 +@2711 := @728 @2372 +@2712 := @2371 @70 +@2714 := @13 @2712 @69 +@2715 := @2371 @67 +@2716 := @615 @2715 +@2724 := {t : @118} -> + {vs : @224} -> {ts : @666} -> (h : @2714) -> (hs : @732) -> @663 (@2716 @73) @681 +@2725 := @2711 @2373 +@2726 := @2371 @71 +@2728 := @13 @2726 @2373 +@2729 := @2371 @68 +@2730 := @615 @2729 +@2732 := @663 (@2730 @73) +@2733 := @627 @2373 +@2734 := @2733 @69 +@2739 := {vs : @224} -> {ts : @666} -> (h : @2728) -> (hs : @732) -> @2732 @2734 +@2740 := @2725 @2600 +@2741 := @2371 @73 +@2743 := @13 @2741 @2373 +@2744 := @2697 @72 +@2746 := @615 @2712 @2688 +@2751 := {ts : @666} -> (h : @2743) -> (hs : @2744) -> @663 @2746 @2734 +@2752 := @2740 @2698 +@2754 := @615 @2726 @2696 +@2755 := @663 @2754 +@2756 := @2733 @2698 +@2759 := (h : @2447) -> (hs : @2706) -> @2755 @2756 +@2760 := @2752 @2445 +@2762 := @615 @2741 @2704 +@2764 := @663 @2762 @2756 +@2765 := (hs : @2710) -> @2764 +@2766 := @2760 @2708 +@2768 := @663 @2602 @2756 +@2769 := @728 @2365 +@2770 := @2171 @68 +@2772 := @13 @2770 @69 +@2773 := @2171 @282 +@2774 := @615 @2773 +@2782 := {t : @118} -> + {vs : @224} -> {ts : @666} -> (h : @2772) -> (hs : @732) -> @663 (@2774 @73) @681 +@2783 := @2769 @2173 +@2784 := @2171 @70 +@2786 := @13 @2784 @2173 +@2787 := @2171 @67 +@2788 := @615 @2787 +@2790 := @663 (@2788 @73) +@2791 := @627 @2173 +@2792 := @2791 @69 +@2797 := {vs : @224} -> {ts : @666} -> (h : @2786) -> (hs : @732) -> @2790 @2792 +@2798 := @2783 @2602 +@2799 := @2171 @71 +@2801 := @13 @2799 @2173 +@2802 := @2755 @72 +@2804 := @615 @2770 @2746 +@2809 := {ts : @666} -> (h : @2801) -> (hs : @2802) -> @663 @2804 @2792 +@2810 := @2798 @2756 +@2812 := @13 @2365 @2173 +@2814 := @615 @2784 @2754 +@2815 := @663 @2814 +@2816 := @2791 @2756 +@2819 := (h : @2812) -> (hs : @2764) -> @2815 @2816 +@2820 := @2810 @2367 +@2822 := @615 @2799 @2762 +@2824 := @663 @2822 @2816 +@2825 := (hs : @2768) -> @2824 +@2826 := @2820 @2766 +@2828 := @663 @2604 @2816 +@2829 := @728 @1585 +@2831 := @13 @1575 @69 +@2832 := @5 @370 +@2833 := @615 @2832 +@2841 := {t : @118} -> + {vs : @224} -> {ts : @666} -> (h : @2831) -> (hs : @732) -> @663 (@2833 @73) @681 +@2842 := @2829 @10 +@2844 := @13 @1591 @10 +@2845 := @5 @282 +@2846 := @615 @2845 +@2848 := @663 (@2846 @73) +@2849 := @627 @10 +@2850 := @2849 @69 +@2855 := {vs : @224} -> {ts : @666} -> (h : @2844) -> (hs : @732) -> @2848 @2850 +@2856 := @2842 @2604 +@2857 := @1573 @10 +@2858 := @2815 @72 +@2859 := @1576 @2804 +@2860 := @663 @2859 +@2864 := {ts : @666} -> (h : @2857) -> (hs : @2858) -> @2860 @2850 +@2865 := @2856 @2816 +@2866 := @1586 @10 +@2867 := @1592 @2814 +@2868 := @663 @2867 +@2869 := @2849 @2816 +@2872 := (h : @2866) -> (hs : @2824) -> @2868 @2869 +@2873 := @2865 @2364 +@2874 := @1603 @2822 +@2875 := @663 @2874 +@2877 := (hs : @2828) -> @2875 @2869 +@2878 := @2873 @2826 +@2879 := @663 @2605 +@2880 := @2879 @2869 +@2881 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.denoteEntry +@2885 := @2881 @71 @73 @69 @72 +@2886 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.entryFits +@2890 := @2886 @71 @73 @69 @72 +@2895 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.entryValue @71 @73 @69 @72 +@2900 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.entry @71 @73 @69 @72 +@2901 := Ne.{1} +@2902 := LexLeanPreservation.Obs +@2903 := @2901 @2902 +@2904 := LexLeanPreservation.Rel +@2907 := @2903 (@2904 @72 @4) +@2908 := LexLeanPreservation.Obs.stuck +@2911 := (f : @2448) -> (v : @116) -> @2907 @2908 +@2913 := LexLeanPreservation.Rust.rel_ne_stuck @2890 +@2922 := (v : @116) -> @2903 (@2904 (@2886 @70 @71 @73 @69) @4) @2908 +@2923 := @2913 @2895 +@2927 := @2903 (@2904 @2890 @2895) @2908 +@2928 := @17 @2606 +@2929 := LexLeanPreservation.Rust.FunSem +@2935 := (n : @37) -> @2929 @370 @282 @67 @4 @68 +@2936 := @28 @2630 +@2937 := @1028 @2936 +@2944 := LexLeanRuntime.index (@17 @2630) @2630 (LexLeanRuntime.instIndexableList @2630) +@2948 := @2937 (@2944 (@2631 @370) @68) +@2949 := @1036 @2630 +@2950 := @2949 @70 +@2951 := @2948 @2950 +@2955 := @638 @378 @370 @282 @70 +@2956 := LexLeanTarget.TargetSyntax.Function.types +@2957 := @2956 @68 +@2958 := @2955 @2957 +@2959 := @28 @2928 +@2960 := @1028 @2959 +@2961 := LexLeanTarget.TargetSemantics.bindAll +@2962 := LexLeanTarget.TargetSyntax.Function.parameters +@2967 := @2960 (@2961 (@2962 @67) @68 @2619) +@2968 := @1036 @2928 +@2969 := @2968 @70 +@2970 := @2967 @2969 +@2971 := @28 @2448 +@2972 := @1028 @2971 +@2973 := LexLeanPreservation.Rust.fnFallible +@2976 := @2972 (@2973 @387 @370) +@2977 := @1036 @2448 +@2978 := @2977 @70 +@2979 := @2976 @2978 +@2980 := LexLeanPreservation.RunConv +@2981 := #13 +@2985 := @2980 @2981 @378 @282 @70 +@2987 := @2903 @68 @2908 +@2988 := Exists.{1} +@2989 := LexLeanPreservation.Rust.ROut +@2990 := @2988 @2989 +@2991 := And +@2992 := LexLeanPreservation.Rust.RealizesFn +@2996 := @2991 (@2992 @370 @282 @4) +@2997 := LexLeanPreservation.Rust.RCI +@2998 := #15 +@2999 := @2997 @2998 +@3000 := LexLeanPreservation.Rust.fnIdent +@3001 := @3000 @2981 +@3008 := (hne : @2987) -> @2990 (fun (ro : @2989) => @2996 (@2999 @3001 @387 @4)) +@3023 := {p : @81} -> + {c : @82} -> + {A : @83} -> + {f : @37} -> + {fn : @2630} -> + {args : @224} -> + {env : @2928} -> + {F : @2448} -> + {o : @2902} -> + (hB : @2935) -> + (hfn : @2951) -> (hwt : @2958) -> (hbind : @2970) -> (hF : @2979) -> (hA : @2985) -> @3008 +@3025 := LexLeanPreservation.Rust.compose @0 +@3026 := @2929 @0 +@3031 := (n : @37) -> @3026 @282 @67 @4 @68 +@3032 := @2944 @2632 +@3035 := @2937 (@3032 @68) @2950 +@3039 := @649 @370 @282 @70 @2957 +@3040 := @2980 @0 +@3043 := @3040 @378 @282 @70 +@3057 := {c : @82} -> + {A : @83} -> + {f : @37} -> + {fn : @2630} -> + {args : @224} -> + {env : @2928} -> + {F : @2448} -> + {o : @2902} -> + (hB : @3031) -> + (hfn : @3035) -> (hwt : @3039) -> (hbind : @2970) -> (hF : @2979) -> (hA : @3043) -> @3008 +@3058 := @3025 @1 +@3059 := @3026 @1 +@3063 := (n : @37) -> @3059 @67 @4 @68 +@3066 := @657 @282 @70 @2957 +@3067 := @2973 @1 +@3070 := @2972 (@3067 @370) @2978 +@3071 := @2997 @1 +@3081 := (hbind : @2970) -> + (hF : @3070) -> + (hA : @3043) -> (hne : @2987) -> @2990 (fun (ro : @2989) => @2996 (@3071 @3001 @387 @4)) +@3091 := {A : @83} -> + {f : @37} -> + {fn : @2630} -> + {args : @224} -> + {env : @2928} -> + {F : @2448} -> {o : @2902} -> (hB : @3063) -> (hfn : @3035) -> (hwt : @3066) -> @3081 +@3092 := @3058 @2 +@3094 := @3059 @2 @4 +@3096 := (n : @37) -> @3094 @68 +@3097 := @663 @70 +@3098 := @3097 @2957 +@3107 := {f : @37} -> + {fn : @2630} -> + {args : @224} -> + {env : @2928} -> + {F : @2448} -> {o : @2902} -> (hB : @3096) -> (hfn : @3035) -> (hwt : @3098) -> @3081 +@3108 := @3092 @2633 +@3110 := (n : @37) -> @3094 @2633 +@3111 := @3032 @2633 +@3112 := @2937 @3111 +@3113 := @3112 @2950 +@3114 := @3067 @2633 +@3115 := @2972 @3114 +@3116 := @3115 @2978 +@3117 := @3040 @2633 +@3119 := @3117 @282 @70 +@3121 := @3071 (@3000 @2633) +@3129 := (hF : @3116) -> + (hA : @3119) -> (hne : @2987) -> @2990 (fun (ro : @2989) => @2996 (@3121 @387 @4)) +@3138 := {fn : @2630} -> + {args : @224} -> + {env : @2928} -> + {F : @2448} -> + {o : @2902} -> (hB : @3110) -> (hfn : @3113) -> (hwt : @3098) -> (hbind : @2970) -> @3129 +@3139 := @3108 @2649 +@3141 := @3112 (@2949 @2649) +@3142 := @2956 @2649 +@3143 := @3097 @3142 +@3145 := @2961 (@2962 @2649) +@3157 := {args : @224} -> + {env : @2928} -> + {F : @2448} -> + {o : @2902} -> + (hB : @3110) -> (hfn : @3141) -> (hwt : @3143) -> (hbind : @2960 (@3145 @68 @2619) @2969) -> @3129 +@3158 := @3139 @2605 +@3162 := @2833 (@2774 (@2716 (@2659 @614))) +@3164 := @663 @3162 @3142 +@3176 := @615 (@5 @378) (@615 (@2171 @370) (@615 (@2371 @282) (@615 (@2459 @67) @614))) +@3180 := @2960 (@3145 @3176 @2619) @2969 +@3192 := @615 (@5 @975) (@615 (@2171 @387) (@615 (@2371 @378) (@615 (@2459 @370) @614))) +@3194 := @3117 @3192 @70 +@3196 := @615 (@5 @2998) +@3197 := #14 +@3222 := {env : @2928} -> + {F : @2448} -> + {o : @2902} -> + (hB : @3110) -> + (hfn : @3141) -> + (hwt : @3164) -> + (hbind : @3180) -> + (hF : @3116) -> + (hA : @3194) -> + (hne : @2987) -> + @2990 + (fun (ro : @2989) => + @2996 (@3121 (@3196 (@615 (@2171 @3197) (@615 (@2371 @2981) (@615 (@2459 @975) @614)))) @4)) +@3223 := @3158 @2628 +@3227 := @2846 (@2788 (@2730 (@2673 @614))) +@3229 := @663 @3227 @3142 +@3246 := @2960 + (@3145 @3162 @2619) + (@2968 + (@2620 (@2611 @2658) (@2620 (@2613 @2715) (@2620 (@2615 @2773) (@2620 (@2617 @2832) @2619))))) +@3258 := @615 (@5 @387) (@615 (@2171 @378) (@615 (@2371 @370) (@615 (@2459 @282) @614))) +@3286 := {F : @2448} -> + {o : @2902} -> + (hB : @3110) -> + (hfn : @3141) -> + (hwt : @3229) -> + (hbind : @3246) -> + (hF : @3116) -> + (hA : @3117 @3258 @70) -> + (hne : @2987) -> + @2990 + (fun (ro : @2989) => + @2996 + (@3121 + (@615 (@5 @3197) (@615 (@2171 @2981) (@615 (@2371 @975) (@615 (@2459 @387) @614)))) + @4)) +@3287 := @3223 @2629 +@3288 := @2860 @3142 +@3305 := @2960 + (@3145 @3227 @2619) + (@2968 + (@2620 (@2611 @2672) (@2620 (@2613 @2729) (@2620 (@2615 @2787) (@2620 (@2617 @2845) @2619))))) +@3307 := @3115 (@2977 @2629) +@3309 := @3117 @3176 @70 +@3310 := @2992 @2629 +@3338 := {o : @2902} -> + (hB : @3110) -> + (hfn : @3141) -> + (hwt : @3288) -> + (hbind : @3305) -> + (hF : @3307) -> + (hA : @3309) -> + (hne : @2987) -> + @2990 + (fun (ro : @2989) => + @2991 + (@3310 @282 @4) + (@3121 (@615 (@5 @2981) (@615 (@2171 @975) (@615 (@2371 @387) (@615 (@2459 @378) @614)))) @4)) +@3339 := @3287 @2885 +@3340 := @2868 @3142 +@3357 := @2960 + (@3145 @2859 @2619) + (@2968 + (@2620 (@2611 @2655) (@2620 (@2613 @2712) (@2620 (@2615 @2770) (@2620 (@2617 @1575) @2619))))) +@3358 := @3117 @3162 +@3362 := @2881 @370 @282 @67 @68 +@3363 := @3358 @3362 +@3367 := @2881 @378 @370 @282 @67 +@3388 := (hB : @3110) -> + (hfn : @3141) -> + (hwt : @3340) -> + (hbind : @3357) -> + (hF : @3307) -> + (hA : @3363) -> + (hne : @2903 @3367 @2908) -> + @2990 (fun (ro : @2989) => @2991 (@3310 (@2881 @975 @387 @378 @370) @4) (@3121 @3192 @4)) +@3389 := @3339 @2653 +@3390 := @2875 @3142 +@3407 := @2960 + (@3145 @2867 @2619) + (@2968 + (@2620 (@2611 @2669) (@2620 (@2613 @2726) (@2620 (@2615 @2784) (@2620 (@2617 @1591) @2619))))) +@3408 := @3117 @3227 +@3412 := @2881 @282 @67 @68 @70 +@3433 := (hfn : @3141) -> + (hwt : @3390) -> + (hbind : @3407) -> + (hF : @3307) -> + (hA : @3408 @3412) -> + (hne : @2903 @3362 @2908) -> + @2990 (fun (ro : @2989) => @2991 (@3310 (@2881 @387 @378 @370 @282) @4) (@3121 @3258 @4)) +@3436 := @3389 (@1136 @2936 @3111) +@3437 := @2879 @3142 +@3454 := @2960 + (@3145 @2874 @2619) + (@2968 + (@2620 (@2611 @2684) (@2620 (@2613 @2741) (@2620 (@2615 @2799) (@2620 (@2617 @1572) @2619))))) +@3455 := @3117 @2859 +@3459 := @2881 @67 @68 @70 @71 +@3475 := (hwt : @3437) -> + (hbind : @3454) -> + (hF : @3307) -> + (hA : @3455 @3459) -> + (hne : @2903 @3412 @2908) -> @2990 (fun (ro : @2989) => @2991 (@3310 @3367 @4) (@3121 @3176 @4)) +@3476 := @3436 @2878 +@3478 := @3145 @2605 @2619 +@3481 := @2960 @3478 (@2968 @2628) +@3482 := @3117 @2867 +@3486 := @2881 @68 @70 @71 @73 +@3501 := (hbind : @3481) -> + (hF : @3307) -> + (hA : @3482 @3486) -> + (hne : @2903 @3459 @2908) -> @2990 (fun (ro : @2989) => @2991 (@3310 @3362 @4) (@3121 @3162 @4)) +@3504 := @3476 (@1136 @2959 @3478) +@3505 := @3117 @2874 +@3509 := @2881 @70 @71 @73 @69 +@3523 := (hF : @3307) -> + (hA : @3505 @3509) -> + (hne : @2903 @3486 @2908) -> @2990 (fun (ro : @2989) => @2991 (@3310 @3412 @4) (@3121 @3227 @4)) +@3526 := @3504 (@1136 @2971 @3114) +@3528 := @3117 @2605 @2885 +@3530 := @2903 @3509 @2908 +@3531 := @3310 @3459 +@3533 := @2991 (@3531 @4) +@3534 := @3121 @2859 +@3535 := @3534 @4 +@3540 := (hA : @3528) -> (hne : @3530) -> @2990 (fun (ro : @2989) => @3533 @3535) +@3541 := @3526 @2900 +@3543 := @2903 @2885 @2908 +@3544 := @3310 @3486 +@3546 := @2991 (@3544 @4) +@3547 := @3121 @2867 +@3552 := (hne : @3543) -> @2990 (fun (ro : @2989) => @3546 (@3547 @4)) +@3553 := @3541 @2923 +@3556 := @2991 (@3310 @3509 @4) +@3558 := @3121 @2874 @4 +@3559 := @3556 @3558 +@3561 := @2990 (fun (ro : @2989) => @3559) +@3562 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.accepts +@3566 := @3562 @71 @73 @69 @72 +@3567 := LexLeanPreservation.someObs +@3568 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.denote +@3573 := @3567 (@3568 @71 @73 @69 @72) +@3575 := LexLeanPreservation.Obs.value @1632 +@3576 := Not +@3577 := @3576 @3566 +@3581 := @3562 @70 @71 @73 @69 +@3586 := @3567 (@3568 @70 @71 @73 @69) +@3587 := @3576 @3581 +@3595 := @3581 -> @3310 (@3567 (@3568 @68 @70 @71 @73)) @72 +@3596 := @3310 @3575 +@3597 := @3596 @72 +@3598 := @3587 -> @3597 +@3600 := @2991 @3595 @3598 +@3604 := @2990 (fun (__e_ro : @2989) => @2991 @3558 @3600) +@3605 := fun (__e_ro : @2989) => @3559 +@3606 := @3544 @72 +@3607 := @3547 @72 +@3608 := And.left +@3609 := And.right +@3612 := @3608 @3606 @3607 @4 +@3615 := @3609 @3606 @3607 @4 +@3616 := @3310 @4 +@3618 := fun (__e_o : @2902) => @3616 @69 +@3619 := Eq.subst.{1} +@3623 := @3562 @68 @70 @71 @73 +@3624 := @3576 @3623 +@3630 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.entry_accepts @67 @68 @70 @71 @4 +@3635 := @3567 (@3568 @67 @68 @70 @71) +@3640 := @3608 (@3531 @69) (@3534 @69) @72 +@3642 := fun (__e_o : @2902) => @3616 @73 +@3645 := @3619 @2902 @3642 @3459 +@3649 := fun (__e_h : @3623) => @3645 @3635 @3630 @3640 +@3655 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.entry_refuses @67 @68 @70 @71 @4 +@3659 := fun (__e_h : @3624) => @3645 @3575 @3655 @3640 +@3660 := And.intro +@3663 := @3623 -> @3310 @3635 @69 +@3665 := @3624 -> @3596 @69 +@3667 := @2991 @3663 @3665 +@3671 := @3660 @3663 @3665 @3649 @3659 +@3675 := @3660 @3607 @3667 @3615 @3671 +@3676 := Exists.intro.{1} +@3677 := @2991 @3535 +@3681 := @3562 @67 @68 @70 @71 +@3695 := fun (__e_ro : @2989) => + @3677 (@2991 (@3681 -> @3310 (@3567 (@3568 @282 @67 @68 @70)) @72) (@3576 @3681 -> @3597)) +@3699 := @3676 @2989 @3695 @72 @3675 +@3701 := @2991 @3606 @3607 +@3703 := fun (__e_ro : @2989) => fun (__e_hand : @3559) => @3699 +@3709 := Exists.elim.{1} @2989 @3605 @3604 @3553 @3703 +@3710 := LexLeanPreservation.Rust.RepresentableL +@3711 := @2171 @69 +@3712 := @2371 @72 +@3714 := @615 @2584 @614 +@3716 := @615 @3712 @3714 +@3720 := @3710 (@1618 (@615 @3711 @3716)) +@3721 := (__e_hrep : @3720) -> @3604 +@3722 := fun (__e_hrep : @3720) => @3709 +@3723 := (spare : @2451) -> @3721 +@3724 := fun (spare : @2451) => @3722 +@3725 := (picks : @2368) -> @3723 +@3726 := fun (picks : @2368) => @3724 +@3727 := (ledger : @2170) -> @3725 +@3728 := fun (ledger : @2170) => @3726 +@3729 := (g : @3) -> @3727 +@3730 := fun (g : @3) => @3728 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R1/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R1/Compose/RustStd.lean deleted file mode 100644 index 0725f44d4..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R1/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd - -/-- The rendering of the root's entry, invoked on the encoded arguments, -realizes the encoded source result when the arguments satisfy §17.12's -invariants, and refuses them with `none` otherwise. -/ -theorem root (m : (List (Prod String Nat))) (k : String) (v : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat)) m), (_root_.LexLeanTarget.TargetSyntax.Value.string k), (_root_.LexLeanTarget.TargetSyntax.Value.nat v)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 10) [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string _root_.LexLeanTarget.TargetSyntax.Value.nat)) m), (_root_.LexLeanTarget.TargetSyntax.Value.string k), (_root_.LexLeanTarget.TargetSyntax.Value.nat v)] __e_ro ∧ - (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.accepts m k v → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.denote m k v)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.accepts m k v → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none) __e_ro) := - match _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd.root __e_n 10) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_string _root_.LexLeanPreservation.Rust.wt_nat)) m) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_string k) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat v) _root_.LexLeanPreservation.Rust.wtl_nil))) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.entry m k v) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) with - | ⟨__e_ro, __e_hr, __e_hc⟩ => ⟨__e_ro, __e_hc, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.entry_accepts m k v __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.entry_refuses m k v __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R1/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R1/Compose/RustStd.lex.tex new file mode 100644 index 000000000..71d7c2ee4 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R1/Compose/RustStd.lex.tex @@ -0,0 +1,728 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd.root : @1520 := @1521 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd.flags +@3 := String +@4 := Nat +@5 := Prod.{0, 0} +@6 := @5 @3 +@7 := @6 @4 +@8 := List.{0} +@9 := @8 @7 +@10 := #3 +@11 := LexLeanTarget.TargetSyntax.Value.string +@12 := LexLeanTarget.TargetSyntax.Value.nat +@13 := LexLeanPreservation.encPair +@14 := @13 @3 +@15 := @14 @4 +@16 := @15 @11 +@17 := @16 @12 +@18 := LexLeanPreservation.encList +@19 := @18 @7 +@20 := @19 @17 +@21 := @20 @10 +@22 := LexLeanTarget.TargetSyntax.Ty.string +@23 := LexLeanTarget.TargetSyntax.Ty.nat +@24 := LexLeanTarget.TargetSyntax.Ty.pair +@25 := @24 @22 +@26 := @25 @23 +@27 := LexLeanTarget.TargetSyntax.Ty.list +@28 := @27 @26 +@29 := #0 +@30 := LexLeanTarget.TargetSyntax.Program +@31 := LexLeanPreservation.Rust.RCrate +@32 := LexLeanPreservation.Rust.Flags +@33 := LexLeanPreservation.Rust.WT +@34 := @33 @10 +@35 := #2 +@36 := @34 @35 +@37 := #1 +@38 := @36 @37 +@39 := @11 @29 +@45 := {p : @30} -> {c : @31} -> {A : @32} -> (s : @3) -> @38 @39 @22 +@47 := LexLeanPreservation.Rust.wt_string @0 +@48 := @33 @0 +@50 := @48 @35 @37 +@55 := {c : @31} -> {A : @32} -> (s : @3) -> @50 @39 @22 +@56 := @47 @1 +@57 := @48 @1 +@58 := @57 @37 +@62 := {A : @32} -> (s : @3) -> @58 @39 @22 +@63 := @56 @2 +@64 := @57 @2 +@65 := @64 @39 +@66 := @65 @22 +@67 := (s : @3) -> @66 +@69 := fun (__x : @3) => @63 @29 +@70 := @12 @29 +@76 := {p : @30} -> {c : @31} -> {A : @32} -> (n : @4) -> @38 @70 @23 +@78 := LexLeanPreservation.Rust.wt_nat @0 +@83 := {c : @31} -> {A : @32} -> (n : @4) -> @50 @70 @23 +@84 := @78 @1 +@88 := {A : @32} -> (n : @4) -> @58 @70 @23 +@89 := @84 @2 +@90 := @64 @70 +@91 := @90 @23 +@92 := (n : @4) -> @91 +@94 := fun (__x : @4) => @89 @29 +@95 := Sort 1 +@96 := LexLeanTarget.TargetSyntax.Value +@97 := (a._@._internal._hyg.#0 : @37) -> @96 +@98 := LexLeanTarget.TargetSyntax.Ty +@99 := #5 +@100 := #9 +@101 := @33 @100 +@102 := #8 +@103 := @101 @102 +@104 := #7 +@105 := @103 @104 +@106 := #4 +@107 := @106 @29 +@110 := (x : @99) -> @105 @107 @35 +@111 := #10 +@117 := (x : @99) -> @33 @111 @100 @102 @107 @35 +@118 := @5 @104 +@119 := #6 +@120 := @118 @119 +@121 := #11 +@124 := @33 @121 @111 @100 +@129 := @13 @102 @104 @119 @99 @29 +@130 := @124 @129 +@132 := @24 @106 @10 +@145 := {p : @30} -> + {c : @31} -> + {A : @32} -> + {α : @95} -> + {β : @95} -> + {ea : @97} -> + {eb : @97} -> {s : @98} -> {t : @98} -> (ha : @110) -> (hb : @117) -> (x : @120) -> @130 @132 +@147 := LexLeanPreservation.Rust.wt_encPair @0 +@172 := {c : @31} -> + {A : @32} -> + {α : @95} -> + {β : @95} -> + {ea : @97} -> + {eb : @97} -> + {s : @98} -> + {t : @98} -> + (ha : (x : @99) -> @48 @102 @104 @107 @35) -> + (hb : (x : @99) -> @48 @100 @102 @107 @35) -> (x : @120) -> @48 @111 @100 @129 @132 +@173 := @147 @1 +@194 := {A : @32} -> + {α : @95} -> + {β : @95} -> + {ea : @97} -> + {eb : @97} -> + {s : @98} -> + {t : @98} -> + (ha : (x : @99) -> @57 @104 @107 @35) -> + (hb : (x : @99) -> @57 @102 @107 @35) -> (x : @120) -> @57 @100 @129 @132 +@195 := @173 @2 +@197 := @64 @107 @35 +@198 := (x : @99) -> @197 +@209 := {α : @95} -> + {β : @95} -> + {ea : @97} -> + {eb : @97} -> {s : @98} -> {t : @98} -> (ha : @198) -> (hb : @198) -> (x : @120) -> @64 @129 @132 +@210 := @195 @3 +@211 := (a._@._internal._hyg.#0 : @3) -> @96 +@212 := (x : @3) -> @197 +@227 := {β : @95} -> + {ea : @211} -> + {eb : @97} -> + {s : @98} -> + {t : @98} -> (ha : @212) -> (hb : @198) -> (x : @6 @119) -> @64 (@14 @104 @119 @99 @29) @132 +@228 := @210 @4 +@229 := (a._@._internal._hyg.#0 : @4) -> @96 +@230 := (x : @4) -> @197 +@242 := {ea : @211} -> + {eb : @229} -> + {s : @98} -> {t : @98} -> (ha : @212) -> (hb : @230) -> (x : @7) -> @64 (@15 @119 @99 @29) @132 +@243 := @228 @11 +@245 := (x : @3) -> @65 @35 +@255 := {eb : @229} -> + {s : @98} -> {t : @98} -> (ha : @245) -> (hb : @230) -> (x : @7) -> @64 (@16 @99 @29) @132 +@256 := @243 @12 +@258 := (x : @4) -> @90 @35 +@260 := @64 (@17 @29) +@266 := {s : @98} -> {t : @98} -> (ha : @245) -> (hb : @258) -> (x : @7) -> @260 @132 +@267 := @256 @22 +@268 := (x : @3) -> @66 +@274 := {t : @98} -> (ha : @268) -> (hb : @258) -> (x : @7) -> @260 (@25 @10) +@275 := @267 @23 +@276 := (x : @4) -> @91 +@278 := (x : @7) -> @260 @26 +@280 := (ha : @268) -> (hb : @276) -> @278 +@284 := fun (__x : @7) => @275 @69 @94 @29 +@285 := (a._@._internal._hyg.#0 : @29) -> @96 +@288 := @33 @119 @99 @106 +@289 := @35 @29 +@292 := (x : @35) -> @288 @289 @37 +@293 := @8 @10 +@296 := @33 @104 @119 @99 +@299 := @18 @106 @10 @29 +@300 := @296 @299 +@301 := @27 @35 +@310 := {p : @30} -> + {c : @31} -> + {A : @32} -> {α : @95} -> {e : @285} -> {t : @98} -> (h : @292) -> (xs : @293) -> @300 @301 +@312 := LexLeanPreservation.Rust.wt_encList @0 +@314 := @48 @99 @106 +@328 := {c : @31} -> + {A : @32} -> + {α : @95} -> + {e : @285} -> + {t : @98} -> (h : (x : @35) -> @314 @289 @37) -> (xs : @293) -> @48 @119 @99 @299 @301 +@329 := @312 @1 +@330 := @57 @106 +@342 := {A : @32} -> + {α : @95} -> + {e : @285} -> {t : @98} -> (h : (x : @35) -> @330 @289 @37) -> (xs : @293) -> @57 @99 @299 @301 +@343 := @329 @2 +@345 := @64 @289 @37 +@353 := {α : @95} -> + {e : @285} -> {t : @98} -> (h : (x : @35) -> @345) -> (xs : @293) -> @64 @299 @301 +@354 := @343 @7 +@364 := {e : (a._@._internal._hyg.#0 : @7) -> @96} -> + {t : @98} -> (h : (x : @7) -> @345) -> (xs : @9) -> @64 (@19 @10 @29) @301 +@365 := @354 @17 +@367 := (x : @7) -> @260 @37 +@369 := @64 (@20 @29) +@373 := {t : @98} -> (h : @367) -> (xs : @9) -> @369 @301 +@374 := @365 @26 +@377 := (h : @278) -> (xs : @9) -> @369 @28 +@379 := @374 @284 @10 +@381 := @64 @21 @28 +@382 := @11 @35 +@383 := @63 @35 +@385 := @64 @382 @22 +@386 := @12 @37 +@387 := @89 @37 +@389 := @64 @386 @23 +@390 := List.nil.{0} +@391 := List.cons.{0} +@392 := @390 @96 +@393 := @391 @96 +@395 := @393 @386 @392 +@397 := @393 @382 @395 +@399 := @393 @21 @397 +@401 := @5 @4 @96 +@402 := 2 +@405 := Prod.mk.{0, 0} @4 @96 +@406 := @405 @402 +@407 := @406 @386 +@409 := @405 1 +@410 := @409 @382 +@412 := @405 0 +@413 := @412 @21 +@414 := @390 @401 +@415 := @391 @401 +@417 := @415 @413 @414 +@419 := @415 @410 @417 +@421 := @415 @407 @419 +@422 := Bool.false +@423 := LexLeanTarget.TargetSyntax.Function +@424 := LexLeanTarget.TargetSyntax.Program.functions +@425 := @424 @0 +@426 := 10 +@427 := @390 @4 +@428 := @390 @98 +@429 := LexLeanTarget.TargetSyntax.Ty.unit +@430 := LexLeanTarget.TargetSyntax.Value.unit +@433 := LexLeanTarget.TargetSyntax.Expr.value @429 @430 +@438 := LexLeanTarget.TargetSyntax.Function.mk @427 @428 @429 @433 +@443 := List.getD.{0} @423 @425 @426 @438 +@447 := fun (__e_n : @4) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd.root @29 @426 +@448 := LexLeanPreservation.Rust.WTL +@456 := {p : @30} -> {c : @31} -> {A : @32} -> @448 @35 @37 @29 @392 @428 +@458 := LexLeanPreservation.Rust.wtl_nil @0 +@459 := @448 @0 +@465 := {c : @31} -> {A : @32} -> @459 @37 @29 @392 @428 +@466 := @458 @1 +@467 := @459 @1 +@471 := {A : @32} -> @467 @29 @392 @428 +@472 := @466 @2 +@473 := @467 @2 +@474 := @473 @392 +@475 := @474 @428 +@476 := @8 @96 +@477 := @8 @98 +@479 := @288 @10 @35 +@484 := @448 @104 @119 @99 @35 @37 +@487 := @448 @102 @104 @119 +@489 := @393 @99 @10 +@490 := @487 @489 +@491 := @391 @98 +@493 := @491 @106 @35 +@503 := {p : @30} -> + {c : @31} -> + {A : @32} -> + {v : @96} -> {t : @98} -> {vs : @476} -> {ts : @477} -> (h : @479) -> (hs : @484) -> @490 @493 +@505 := LexLeanPreservation.Rust.wtl_cons @0 +@523 := {c : @31} -> + {A : @32} -> + {v : @96} -> + {t : @98} -> + {vs : @476} -> + {ts : @477} -> (h : @314 @10 @35) -> (hs : @459 @119 @99 @35 @37) -> @459 @104 @119 @489 @493 +@524 := @505 @1 +@539 := {A : @32} -> + {v : @96} -> + {t : @98} -> + {vs : @476} -> {ts : @477} -> (h : @330 @10 @35) -> (hs : @467 @99 @35 @37) -> @467 @119 @489 @493 +@540 := @524 @2 +@542 := @64 @10 @35 +@544 := @473 @35 @37 +@552 := {v : @96} -> + {t : @98} -> {vs : @476} -> {ts : @477} -> (h : @542) -> (hs : @544) -> @473 @489 @493 +@553 := @540 @386 +@554 := @12 @106 +@556 := @64 @554 @35 +@557 := @12 @119 +@558 := @393 @557 +@566 := {t : @98} -> {vs : @476} -> {ts : @477} -> (h : @556) -> (hs : @544) -> @473 (@558 @10) @493 +@567 := @553 @23 +@568 := @12 @10 +@570 := @64 @568 @23 +@571 := @12 @99 +@572 := @393 @571 +@574 := @473 (@572 @10) +@575 := @491 @23 +@576 := @575 @35 +@581 := {vs : @476} -> {ts : @477} -> (h : @570) -> (hs : @544) -> @574 @576 +@582 := @567 @392 +@583 := @12 @35 +@585 := @64 @583 @23 +@586 := @474 @37 +@588 := @393 @554 @392 +@593 := {ts : @477} -> (h : @585) -> (hs : @586) -> @473 @588 @576 +@594 := @582 @428 +@596 := @393 @568 @392 +@597 := @473 @596 +@598 := @575 @428 +@601 := (h : @389) -> (hs : @475) -> @597 @598 +@602 := @594 @387 +@604 := @393 @583 @392 +@606 := @473 @604 @598 +@607 := (hs : @475) -> @606 +@608 := @602 @472 +@610 := @473 @395 @598 +@611 := @540 @382 +@612 := @11 @99 +@614 := @64 @612 @35 +@615 := @11 @104 +@616 := @393 @615 +@624 := {t : @98} -> {vs : @476} -> {ts : @477} -> (h : @614) -> (hs : @544) -> @473 (@616 @10) @493 +@625 := @611 @22 +@626 := @11 @106 +@628 := @64 @626 @22 +@629 := @11 @119 +@630 := @393 @629 +@632 := @473 (@630 @10) +@633 := @491 @22 +@634 := @633 @35 +@639 := {vs : @476} -> {ts : @477} -> (h : @628) -> (hs : @544) -> @632 @634 +@640 := @625 @395 +@641 := @11 @10 +@643 := @64 @641 @22 +@644 := @597 @37 +@646 := @393 @612 @588 +@651 := {ts : @477} -> (h : @643) -> (hs : @644) -> @473 @646 @634 +@652 := @640 @598 +@654 := @393 @626 @596 +@655 := @473 @654 +@656 := @633 @598 +@659 := (h : @385) -> (hs : @606) -> @655 @656 +@660 := @652 @383 +@662 := @393 @641 @604 +@664 := @473 @662 @656 +@665 := (hs : @610) -> @664 +@666 := @660 @608 +@668 := @473 @397 @656 +@669 := @540 @21 +@670 := @20 @119 +@672 := @64 @670 @35 +@673 := @20 @102 +@674 := @393 @673 +@682 := {t : @98} -> {vs : @476} -> {ts : @477} -> (h : @672) -> (hs : @544) -> @473 (@674 @10) @493 +@683 := @669 @28 +@684 := @20 @99 +@686 := @64 @684 @28 +@687 := @20 @104 +@688 := @393 @687 +@690 := @473 (@688 @10) +@691 := @491 @28 +@692 := @691 @35 +@697 := {vs : @476} -> {ts : @477} -> (h : @686) -> (hs : @544) -> @690 @692 +@698 := @683 @397 +@699 := @20 @106 +@701 := @64 @699 @28 +@702 := @655 @37 +@704 := @393 @670 @646 +@705 := @473 @704 +@709 := {ts : @477} -> (h : @701) -> (hs : @702) -> @705 @692 +@710 := @698 @656 +@712 := @393 @684 @654 +@713 := @473 @712 +@714 := @691 @656 +@717 := (h : @381) -> (hs : @664) -> @713 @714 +@718 := @710 @379 +@720 := @393 @699 @662 +@721 := @473 @720 +@723 := (hs : @668) -> @721 @714 +@724 := @718 @666 +@725 := @473 @399 +@726 := @725 @714 +@727 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.denoteEntry +@730 := @727 @10 @35 @37 +@731 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.entryFits +@734 := @731 @10 @35 @37 +@738 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.entryValue @10 @35 @37 +@742 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.entry @10 @35 @37 +@743 := Bool +@744 := Ne.{1} +@745 := LexLeanPreservation.Obs +@746 := @744 @745 +@747 := LexLeanPreservation.Rel +@750 := @746 (@747 @37 @29) +@751 := LexLeanPreservation.Obs.stuck +@754 := (f : @743) -> (v : @96) -> @750 @751 +@756 := LexLeanPreservation.Rust.rel_ne_stuck @734 +@764 := (v : @96) -> @746 (@747 (@731 @106 @10 @35) @29) @751 +@765 := @756 @738 +@769 := @746 (@747 @734 @738) @751 +@770 := @8 @401 +@771 := LexLeanPreservation.Rust.FunSem +@777 := (n : @4) -> @771 @100 @102 @104 @29 @119 +@778 := Eq.{1} +@779 := Option.{0} +@780 := @779 @423 +@781 := @778 @780 +@788 := LexLeanRuntime.index (@8 @423) @423 (LexLeanRuntime.instIndexableList @423) +@792 := @781 (@788 (@424 @100) @119) +@793 := Option.some.{0} +@794 := @793 @423 +@795 := @794 @99 +@796 := @792 @795 +@800 := @448 @111 @100 @102 @99 +@801 := LexLeanTarget.TargetSyntax.Function.types +@802 := @801 @119 +@803 := @800 @802 +@804 := @779 @770 +@805 := @778 @804 +@806 := LexLeanTarget.TargetSemantics.bindAll +@807 := LexLeanTarget.TargetSyntax.Function.parameters +@812 := @805 (@806 (@807 @104) @119 @414) +@813 := @793 @770 +@814 := @813 @99 +@815 := @812 @814 +@816 := @779 @743 +@817 := @778 @816 +@818 := LexLeanPreservation.Rust.fnFallible +@821 := @817 (@818 @121 @100) +@822 := @793 @743 +@823 := @822 @99 +@824 := @821 @823 +@825 := LexLeanPreservation.RunConv +@826 := #13 +@830 := @825 @826 @111 @102 @99 +@832 := @746 @119 @751 +@833 := Exists.{1} +@834 := LexLeanPreservation.Rust.ROut +@835 := @833 @834 +@836 := And +@837 := LexLeanPreservation.Rust.RealizesFn +@841 := @836 (@837 @100 @102 @29) +@842 := LexLeanPreservation.Rust.RCI +@844 := @842 #15 +@845 := LexLeanPreservation.Rust.fnIdent +@846 := @845 @826 +@853 := (hne : @832) -> @835 (fun (ro : @834) => @841 (@844 @846 @121 @29)) +@868 := {p : @30} -> + {c : @31} -> + {A : @32} -> + {f : @4} -> + {fn : @423} -> + {args : @476} -> + {env : @770} -> + {F : @743} -> + {o : @745} -> + (hB : @777) -> + (hfn : @796) -> (hwt : @803) -> (hbind : @815) -> (hF : @824) -> (hA : @830) -> @853 +@870 := LexLeanPreservation.Rust.compose @0 +@871 := @771 @0 +@876 := (n : @4) -> @871 @102 @104 @29 @119 +@877 := @788 @425 +@880 := @781 (@877 @119) @795 +@884 := @459 @100 @102 @99 @802 +@885 := @825 @0 +@888 := @885 @111 @102 @99 +@902 := {c : @31} -> + {A : @32} -> + {f : @4} -> + {fn : @423} -> + {args : @476} -> + {env : @770} -> + {F : @743} -> + {o : @745} -> + (hB : @876) -> + (hfn : @880) -> (hwt : @884) -> (hbind : @815) -> (hF : @824) -> (hA : @888) -> @853 +@903 := @870 @1 +@904 := @871 @1 +@908 := (n : @4) -> @904 @104 @29 @119 +@911 := @467 @102 @99 @802 +@912 := @818 @1 +@915 := @817 (@912 @100) @823 +@916 := @842 @1 +@926 := (hbind : @815) -> + (hF : @915) -> (hA : @888) -> (hne : @832) -> @835 (fun (ro : @834) => @841 (@916 @846 @121 @29)) +@936 := {A : @32} -> + {f : @4} -> + {fn : @423} -> + {args : @476} -> + {env : @770} -> {F : @743} -> {o : @745} -> (hB : @908) -> (hfn : @880) -> (hwt : @911) -> @926 +@937 := @903 @2 +@939 := @904 @2 @29 +@941 := (n : @4) -> @939 @119 +@942 := @473 @99 +@943 := @942 @802 +@952 := {f : @4} -> + {fn : @423} -> + {args : @476} -> + {env : @770} -> {F : @743} -> {o : @745} -> (hB : @941) -> (hfn : @880) -> (hwt : @943) -> @926 +@953 := @937 @426 +@955 := (n : @4) -> @939 @426 +@956 := @877 @426 +@957 := @781 @956 +@958 := @957 @795 +@959 := @912 @426 +@960 := @817 @959 +@961 := @960 @823 +@962 := @885 @426 +@964 := @962 @102 @99 +@966 := @916 (@845 @426) +@974 := (hF : @961) -> (hA : @964) -> (hne : @832) -> @835 (fun (ro : @834) => @841 (@966 @121 @29)) +@983 := {fn : @423} -> + {args : @476} -> + {env : @770} -> + {F : @743} -> {o : @745} -> (hB : @955) -> (hfn : @958) -> (hwt : @943) -> (hbind : @815) -> @974 +@984 := @953 @443 +@986 := @957 (@794 @443) +@987 := @801 @443 +@988 := @942 @987 +@990 := @806 (@807 @443) +@1002 := {args : @476} -> + {env : @770} -> + {F : @743} -> + {o : @745} -> + (hB : @955) -> (hfn : @986) -> (hwt : @988) -> (hbind : @805 (@990 @119 @414) @814) -> @974 +@1003 := @984 @399 +@1006 := @674 (@616 (@558 @392)) +@1008 := @473 @1006 @987 +@1017 := @393 (@20 @100) (@393 (@11 @102) (@393 (@12 @104) @392)) +@1021 := @805 (@990 @1017 @414) @814 +@1030 := @393 (@20 @121) (@393 (@11 @111) (@393 (@12 @100) @392)) +@1032 := @962 @1030 @99 +@1035 := @393 (@20 #14) +@1037 := @393 (@11 @826) +@1038 := #12 +@1058 := {env : @770} -> + {F : @743} -> + {o : @745} -> + (hB : @955) -> + (hfn : @986) -> + (hwt : @1008) -> + (hbind : @1021) -> + (hF : @961) -> + (hA : @1032) -> + (hne : @832) -> @835 (fun (ro : @834) => @841 (@966 (@1035 (@1037 (@393 (@12 @1038) @392))) @29)) +@1059 := @1003 @421 +@1062 := @688 (@630 (@572 @392)) +@1064 := @473 @1062 @987 +@1078 := @805 (@990 @1006 @414) (@813 (@415 (@406 @557) (@415 (@409 @615) (@415 (@412 @673) @414)))) +@1087 := @393 (@20 @111) (@393 (@11 @100) (@393 (@12 @102) @392)) +@1112 := {F : @743} -> + {o : @745} -> + (hB : @955) -> + (hfn : @986) -> + (hwt : @1064) -> + (hbind : @1078) -> + (hF : @961) -> + (hA : @962 @1087 @99) -> + (hne : @832) -> + @835 + (fun (ro : @834) => @841 (@966 (@393 (@20 @826) (@393 (@11 @1038) (@393 (@12 @121) @392))) @29)) +@1113 := @1059 @422 +@1114 := @705 @987 +@1128 := @805 (@990 @1062 @414) (@813 (@415 (@406 @571) (@415 (@409 @629) (@415 (@412 @687) @414)))) +@1130 := @960 (@822 @422) +@1132 := @962 @1017 @99 +@1133 := @837 @422 +@1158 := {o : @745} -> + (hB : @955) -> + (hfn : @986) -> + (hwt : @1114) -> + (hbind : @1128) -> + (hF : @1130) -> + (hA : @1132) -> + (hne : @832) -> + @835 + (fun (ro : @834) => + @836 (@1133 @102 @29) (@966 (@393 (@20 @1038) (@393 (@11 @121) (@393 (@12 @111) @392))) @29)) +@1159 := @1113 @730 +@1160 := @713 @987 +@1174 := @805 (@990 @704 @414) (@813 (@415 (@406 @554) (@415 (@409 @612) (@415 (@412 @670) @414)))) +@1175 := @962 @1006 +@1178 := @727 @102 @104 @119 +@1179 := @1175 @1178 +@1182 := @727 @100 @102 @104 +@1202 := (hB : @955) -> + (hfn : @986) -> + (hwt : @1160) -> + (hbind : @1174) -> + (hF : @1130) -> + (hA : @1179) -> + (hne : @746 @1182 @751) -> + @835 (fun (ro : @834) => @836 (@1133 (@727 @121 @111 @100) @29) (@966 @1030 @29)) +@1203 := @1159 @447 +@1204 := @721 @987 +@1218 := @805 (@990 @712 @414) (@813 (@415 (@406 @568) (@415 (@409 @626) (@415 (@412 @684) @414)))) +@1219 := @962 @1062 +@1222 := @727 @104 @119 @99 +@1242 := (hfn : @986) -> + (hwt : @1204) -> + (hbind : @1218) -> + (hF : @1130) -> + (hA : @1219 @1222) -> + (hne : @746 @1178 @751) -> + @835 (fun (ro : @834) => @836 (@1133 (@727 @111 @100 @102) @29) (@966 @1087 @29)) +@1243 := Eq.refl.{1} +@1246 := @1203 (@1243 @780 @956) +@1247 := @725 @987 +@1261 := @805 (@990 @720 @414) (@813 (@415 (@406 @583) (@415 (@409 @641) (@415 (@412 @699) @414)))) +@1262 := @962 @704 +@1265 := @727 @119 @99 @106 +@1281 := (hwt : @1247) -> + (hbind : @1261) -> + (hF : @1130) -> + (hA : @1262 @1265) -> + (hne : @746 @1222 @751) -> @835 (fun (ro : @834) => @836 (@1133 @1182 @29) (@966 @1017 @29)) +@1282 := @1246 @724 +@1284 := @990 @399 @414 +@1287 := @805 @1284 (@813 @421) +@1288 := @962 @712 +@1291 := @727 @99 @106 @10 +@1306 := (hbind : @1287) -> + (hF : @1130) -> + (hA : @1288 @1291) -> + (hne : @746 @1265 @751) -> @835 (fun (ro : @834) => @836 (@1133 @1178 @29) (@966 @1006 @29)) +@1309 := @1282 (@1243 @804 @1284) +@1310 := @962 @720 +@1313 := @727 @106 @10 @35 +@1327 := (hF : @1130) -> + (hA : @1310 @1313) -> + (hne : @746 @1291 @751) -> @835 (fun (ro : @834) => @836 (@1133 @1222 @29) (@966 @1062 @29)) +@1330 := @1309 (@1243 @816 @959) +@1332 := @962 @399 @730 +@1334 := @746 @1313 @751 +@1335 := @1133 @1265 +@1337 := @836 (@1335 @29) +@1338 := @966 @704 +@1339 := @1338 @29 +@1344 := (hA : @1332) -> (hne : @1334) -> @835 (fun (ro : @834) => @1337 @1339) +@1345 := @1330 @742 +@1347 := @746 @730 @751 +@1348 := @1133 @1291 +@1350 := @836 (@1348 @29) +@1351 := @966 @712 +@1356 := (hne : @1347) -> @835 (fun (ro : @834) => @1350 (@1351 @29)) +@1357 := @1345 @765 +@1360 := @836 (@1133 @1313 @29) +@1362 := @966 @720 @29 +@1363 := @1360 @1362 +@1365 := @835 (fun (ro : @834) => @1363) +@1366 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.accepts +@1369 := @1366 @10 @35 @37 +@1370 := LexLeanPreservation.someObs +@1371 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.denote +@1375 := @1370 (@1371 @10 @35 @37) +@1378 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none +@1379 := Not +@1380 := @1379 @1369 +@1383 := @1366 @106 @10 @35 +@1387 := @1370 (@1371 @106 @10 @35) +@1388 := @1379 @1383 +@1395 := @1383 -> @1133 (@1370 (@1371 @99 @106 @10)) @37 +@1396 := @1133 @1378 +@1397 := @1396 @37 +@1398 := @1388 -> @1397 +@1400 := @836 @1395 @1398 +@1404 := @835 (fun (__e_ro : @834) => @836 @1362 @1400) +@1405 := fun (__e_ro : @834) => @1363 +@1406 := @1348 @37 +@1407 := @1351 @37 +@1408 := And.left +@1409 := And.right +@1412 := @1408 @1406 @1407 @29 +@1415 := @1409 @1406 @1407 @29 +@1416 := @1133 @29 +@1418 := fun (__e_o : @745) => @1416 @35 +@1419 := Eq.subst.{1} +@1422 := @1366 @99 @106 @10 +@1423 := @1379 @1422 +@1428 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.entry_accepts @119 @99 @106 @29 +@1432 := @1370 (@1371 @119 @99 @106) +@1437 := @1408 (@1335 @35) (@1338 @35) @37 +@1439 := fun (__e_o : @745) => @1416 @10 +@1442 := @1419 @745 @1439 @1265 +@1446 := fun (__e_h : @1422) => @1442 @1432 @1428 @1437 +@1451 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.entry_refuses @119 @99 @106 @29 +@1455 := fun (__e_h : @1423) => @1442 @1378 @1451 @1437 +@1456 := And.intro +@1459 := @1422 -> @1133 @1432 @35 +@1461 := @1423 -> @1396 @35 +@1463 := @836 @1459 @1461 +@1467 := @1456 @1459 @1461 @1446 @1455 +@1471 := @1456 @1407 @1463 @1415 @1467 +@1472 := Exists.intro.{1} +@1473 := @836 @1339 +@1476 := @1366 @119 @99 @106 +@1489 := fun (__e_ro : @834) => + @1473 (@836 (@1476 -> @1133 (@1370 (@1371 @104 @119 @99)) @37) (@1379 @1476 -> @1397)) +@1493 := @1472 @834 @1489 @37 @1471 +@1495 := @836 @1406 @1407 +@1497 := fun (__e_ro : @834) => fun (__e_hand : @1363) => @1493 +@1503 := Exists.elim.{1} @834 @1405 @1404 @1357 @1497 +@1504 := LexLeanPreservation.Rust.RepresentableL +@1505 := @20 @35 +@1506 := @11 @37 +@1508 := @393 @70 @392 +@1510 := @393 @1506 @1508 +@1513 := @1504 (@393 @1505 @1510) +@1514 := (__e_hrep : @1513) -> @1404 +@1515 := fun (__e_hrep : @1513) => @1503 +@1516 := (v : @4) -> @1514 +@1517 := fun (v : @4) => @1515 +@1518 := (k : @3) -> @1516 +@1519 := fun (k : @3) => @1517 +@1520 := (m : @9) -> @1518 +@1521 := fun (m : @9) => @1519 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustCore.lean deleted file mode 100644 index 86c87057e..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Nat) (b : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustCore.lex.tex new file mode 100644 index 000000000..0bb75c40c --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustCore.lex.tex @@ -0,0 +1,462 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore.root : @914 := @915 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@65 := Prod.{0, 0} @3 @54 +@66 := 1 +@69 := Prod.mk.{0, 0} @3 @54 +@70 := @69 @66 +@71 := @70 @50 +@72 := 0 +@73 := @69 @72 +@74 := @73 @6 +@75 := @55 @65 +@76 := @56 @65 +@78 := @76 @74 @75 +@80 := @76 @71 @78 +@81 := Bool.true +@82 := LexLeanTarget.TargetSyntax.Function +@83 := LexLeanTarget.TargetSyntax.Program.functions +@84 := @83 @0 +@85 := LexLeanTarget.TargetSyntax.Ty +@86 := @55 @3 +@87 := @55 @85 +@88 := LexLeanTarget.TargetSyntax.Ty.unit +@89 := LexLeanTarget.TargetSyntax.Value.unit +@92 := LexLeanTarget.TargetSyntax.Expr.value @88 @89 +@97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 +@102 := List.getD.{0} @82 @84 @72 @97 +@106 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore.root @17 @72 +@107 := LexLeanPreservation.Rust.WTL +@115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 +@117 := LexLeanPreservation.Rust.wtl_nil @0 +@118 := @107 @0 +@124 := {c : @9} -> {A : @10} -> @118 @15 @17 @57 @87 +@125 := @117 @1 +@126 := @118 @1 +@130 := {A : @10} -> @126 @17 @57 @87 +@131 := @125 @2 +@132 := @126 @2 +@133 := @132 @57 +@134 := @133 @87 +@135 := List.{0} +@136 := @135 @54 +@137 := @135 @85 +@138 := #6 +@139 := @11 @138 +@140 := #5 +@141 := @139 @140 +@142 := #4 +@145 := @141 @142 @12 @4 +@146 := #7 +@151 := @107 @146 @138 @140 @4 @15 +@152 := #8 +@155 := @107 @152 @146 @138 +@157 := @58 @140 @12 +@158 := @155 @157 +@159 := @56 @85 +@161 := @159 @142 @4 +@171 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @145) -> (hs : @151) -> @158 @161 +@173 := LexLeanPreservation.Rust.wtl_cons @0 +@193 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> + (h : @27 @140 @142 @12 @4) -> (hs : @118 @138 @140 @4 @15) -> @118 @146 @138 @157 @161 +@194 := @173 @1 +@210 := {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> (h : @36 @142 @12 @4) -> (hs : @126 @140 @4 @15) -> @126 @138 @157 @161 +@211 := @194 @2 +@213 := @43 @12 @4 +@215 := @132 @4 @15 +@223 := {v : @54} -> + {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @213) -> (hs : @215) -> @132 @157 @161 +@224 := @211 @50 +@225 := @5 @142 +@226 := @43 @225 +@227 := @226 @4 +@228 := @5 @138 +@229 := @58 @228 +@231 := @132 (@229 @12) +@237 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @227) -> (hs : @215) -> @231 @161 +@238 := @224 @7 +@239 := @5 @12 +@241 := @43 @239 @7 +@242 := @5 @140 +@243 := @58 @242 +@245 := @132 (@243 @12) +@246 := @159 @7 +@247 := @246 @4 +@252 := {vs : @136} -> {ts : @137} -> (h : @241) -> (hs : @215) -> @245 @247 +@253 := @238 @57 +@254 := @133 @15 +@255 := @58 @225 +@256 := @255 @57 +@261 := {ts : @137} -> (h : @49) -> (hs : @254) -> @132 @256 @247 +@262 := @253 @87 +@263 := @58 @239 +@264 := @263 @57 +@265 := @132 @264 +@266 := @246 @87 +@269 := (h : @53) -> (hs : @134) -> @265 @266 +@270 := @262 @51 +@271 := @61 @57 +@273 := @132 @271 @266 +@274 := (hs : @134) -> @273 +@275 := @270 @131 +@277 := @132 @60 @266 +@278 := @211 @6 +@280 := @43 @242 @4 +@281 := @5 @146 +@282 := @58 @281 +@290 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @280) -> (hs : @215) -> @132 (@282 @12) @161 +@291 := @278 @7 +@297 := {vs : @136} -> {ts : @137} -> (h : @226 @7) -> (hs : @215) -> @231 @247 +@298 := @291 @60 +@299 := @265 @15 +@300 := @243 @256 +@301 := @132 @300 +@305 := {ts : @137} -> (h : @241) -> (hs : @299) -> @301 @247 +@306 := @298 @266 +@307 := @255 @264 +@308 := @132 @307 +@309 := @246 @266 +@312 := (h : @49) -> (hs : @273) -> @308 @309 +@313 := @306 @47 +@314 := @263 @271 +@315 := @132 @314 +@317 := (hs : @277) -> @315 @309 +@318 := @313 @275 +@319 := @132 @62 +@320 := @319 @309 +@321 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.__fits_0 +@326 := @324 @4 @15 +@330 := @5 (Coverage.Main.natOps @4 @15) +@333 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.root @4 @15 +@334 := Bool +@335 := Ne.{1} +@336 := LexLeanPreservation.Obs +@337 := @335 @336 +@338 := LexLeanPreservation.Rel +@341 := @337 (@338 @15 @17) +@342 := LexLeanPreservation.Obs.stuck +@345 := (f : @334) -> (v : @54) -> @341 @342 +@347 := LexLeanPreservation.Rust.rel_ne_stuck @326 +@354 := (v : @54) -> @337 (@338 (@324 @12 @4) @17) @342 +@355 := @347 @330 +@359 := @337 (@338 @326 @330) @342 +@360 := @135 @65 +@361 := LexLeanPreservation.Rust.FunSem +@362 := #9 +@368 := (n : @3) -> @361 @362 @152 @146 @17 @138 +@369 := Eq.{1} +@370 := Option.{0} +@371 := @370 @82 +@372 := @369 @371 +@379 := LexLeanRuntime.index (@135 @82) @82 (LexLeanRuntime.instIndexableList @82) +@383 := @372 (@379 (@83 @362) @138) +@384 := Option.some.{0} +@385 := @384 @82 +@386 := @385 @140 +@387 := @383 @386 +@388 := #10 +@392 := @107 @388 @362 @152 @140 +@393 := LexLeanTarget.TargetSyntax.Function.types +@394 := @393 @138 +@395 := @392 @394 +@396 := @370 @360 +@397 := @369 @396 +@398 := LexLeanTarget.TargetSemantics.bindAll +@399 := LexLeanTarget.TargetSyntax.Function.parameters +@404 := @397 (@398 (@399 @146) @138 @75) +@405 := @384 @360 +@406 := @405 @140 +@407 := @404 @406 +@408 := @370 @334 +@409 := @369 @408 +@410 := LexLeanPreservation.Rust.fnFallible +@411 := #11 +@414 := @409 (@410 @411 @362) +@415 := @384 @334 +@416 := @415 @140 +@417 := @414 @416 +@418 := LexLeanPreservation.RunConv +@419 := #13 +@423 := @418 @419 @388 @152 @140 +@425 := @337 @138 @342 +@426 := Exists.{1} +@427 := LexLeanPreservation.Rust.ROut +@428 := @426 @427 +@429 := And +@430 := LexLeanPreservation.Rust.RealizesFn +@434 := @429 (@430 @362 @152 @17) +@435 := LexLeanPreservation.Rust.RCI +@437 := @435 #15 +@438 := LexLeanPreservation.Rust.fnIdent +@439 := @438 @419 +@446 := (hne : @425) -> @428 (fun (ro : @427) => @434 (@437 @439 @411 @17)) +@461 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @368) -> + (hfn : @387) -> (hwt : @395) -> (hbind : @407) -> (hF : @417) -> (hA : @423) -> @446 +@463 := LexLeanPreservation.Rust.compose @0 +@464 := @361 @0 +@469 := (n : @3) -> @464 @152 @146 @17 @138 +@470 := @379 @84 +@473 := @372 (@470 @138) @386 +@477 := @118 @362 @152 @140 @394 +@478 := @418 @0 +@481 := @478 @388 @152 @140 +@495 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @469) -> + (hfn : @473) -> (hwt : @477) -> (hbind : @407) -> (hF : @417) -> (hA : @481) -> @446 +@496 := @463 @1 +@497 := @464 @1 +@501 := (n : @3) -> @497 @146 @17 @138 +@504 := @126 @152 @140 @394 +@505 := @410 @1 +@508 := @409 (@505 @362) @416 +@509 := @435 @1 +@519 := (hbind : @407) -> + (hF : @508) -> (hA : @481) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@509 @439 @411 @17)) +@529 := {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> {F : @334} -> {o : @336} -> (hB : @501) -> (hfn : @473) -> (hwt : @504) -> @519 +@530 := @496 @2 +@532 := @497 @2 @17 +@534 := (n : @3) -> @532 @138 +@535 := @132 @140 +@536 := @535 @394 +@545 := {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> {F : @334} -> {o : @336} -> (hB : @534) -> (hfn : @473) -> (hwt : @536) -> @519 +@546 := @530 @72 +@548 := (n : @3) -> @532 @72 +@549 := @470 @72 +@550 := @372 @549 +@551 := @550 @386 +@552 := @505 @72 +@553 := @409 @552 +@554 := @553 @416 +@555 := @478 @72 +@557 := @555 @152 @140 +@559 := @509 (@438 @72) +@567 := (hF : @554) -> (hA : @557) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 @411 @17)) +@576 := {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> {o : @336} -> (hB : @548) -> (hfn : @551) -> (hwt : @536) -> (hbind : @407) -> @567 +@577 := @546 @102 +@579 := @550 (@385 @102) +@580 := @393 @102 +@581 := @535 @580 +@583 := @398 (@399 @102) +@595 := {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @548) -> (hfn : @579) -> (hwt : @581) -> (hbind : @397 (@583 @138 @75) @406) -> @567 +@596 := @577 @62 +@598 := @282 (@229 @57) +@600 := @132 @598 @580 +@602 := @58 (@5 @152) +@604 := @602 (@282 @57) +@608 := @397 (@583 @604 @75) @406 +@610 := @58 (@5 @388) +@612 := @58 (@5 @362) +@614 := @610 (@612 @57) +@616 := @555 @614 @140 +@618 := @58 (@5 @419) +@621 := @58 (@5 #12) +@638 := {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @600) -> + (hbind : @608) -> + (hF : @554) -> + (hA : @616) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 (@618 (@621 @57)) @17)) +@639 := @596 @80 +@641 := @229 (@243 @57) +@643 := @132 @641 @580 +@654 := @397 (@583 @598 @75) (@405 (@76 (@70 @228) (@76 (@73 @281) @75))) +@656 := @612 (@602 @57) +@658 := @555 @656 @140 +@660 := @58 (@5 @411) +@676 := {F : @334} -> + {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @643) -> + (hbind : @654) -> + (hF : @554) -> + (hA : @658) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 (@621 (@660 @57)) @17)) +@677 := @639 @81 +@678 := @301 @580 +@689 := @397 (@583 @641 @75) (@405 (@76 (@70 @242) (@76 (@73 @228) @75))) +@691 := @553 (@415 @81) +@693 := @555 @604 @140 +@694 := @430 @81 +@712 := {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @678) -> + (hbind : @689) -> + (hF : @691) -> + (hA : @693) -> + (hne : @425) -> @428 (fun (ro : @427) => @429 (@694 @152 @17) (@559 (@660 (@610 @57)) @17)) +@713 := @677 @323 +@714 := @308 @580 +@725 := @397 (@583 @300 @75) (@405 (@76 (@70 @225) (@76 (@73 @242) @75))) +@726 := @555 @598 +@728 := @321 @146 @138 +@729 := @726 @728 +@731 := @321 @152 @146 +@750 := (hB : @548) -> + (hfn : @579) -> + (hwt : @714) -> + (hbind : @725) -> + (hF : @691) -> + (hA : @729) -> + (hne : @337 @731 @342) -> + @428 (fun (ro : @427) => @429 (@694 (@321 @388 @362) @17) (@559 @614 @17)) +@751 := @713 @106 +@752 := @315 @580 +@763 := @397 (@583 @307 @75) (@405 (@76 (@70 @239) (@76 (@73 @225) @75))) +@764 := @555 @641 +@766 := @321 @138 @140 +@785 := (hfn : @579) -> + (hwt : @752) -> + (hbind : @763) -> + (hF : @691) -> + (hA : @764 @766) -> + (hne : @337 @728 @342) -> + @428 (fun (ro : @427) => @429 (@694 (@321 @362 @152) @17) (@559 @656 @17)) +@786 := Eq.refl.{1} +@789 := @751 (@786 @371 @549) +@790 := @319 @580 +@801 := @397 (@583 @314 @75) (@405 (@76 (@70 @6) (@76 (@73 @239) @75))) +@802 := @555 @300 +@804 := @321 @140 @142 +@820 := (hwt : @790) -> + (hbind : @801) -> + (hF : @691) -> + (hA : @802 @804) -> + (hne : @337 @766 @342) -> @428 (fun (ro : @427) => @429 (@694 @731 @17) (@559 @604 @17)) +@821 := @789 @318 +@823 := @583 @62 @75 +@826 := @397 @823 (@405 @80) +@827 := @555 @307 +@829 := @321 @142 @12 +@844 := (hbind : @826) -> + (hF : @691) -> + (hA : @827 @829) -> + (hne : @337 @804 @342) -> @428 (fun (ro : @427) => @429 (@694 @728 @17) (@559 @598 @17)) +@847 := @821 (@786 @396 @823) +@848 := @555 @314 +@850 := @321 @12 @4 +@864 := (hF : @691) -> + (hA : @848 @850) -> + (hne : @337 @829 @342) -> @428 (fun (ro : @427) => @429 (@694 @766 @17) (@559 @641 @17)) +@867 := @847 (@786 @408 @552) +@881 := (hA : @555 @62 @323) -> + (hne : @337 @850 @342) -> @428 (fun (ro : @427) => @429 (@694 @804 @17) (@559 @300 @17)) +@882 := @867 @333 +@893 := (hne : @337 @323 @342) -> @428 (fun (ro : @427) => @429 (@694 @829 @17) (@559 @307 @17)) +@894 := @882 @355 +@900 := @429 (@694 @850 @17) (@559 @314 @17) +@902 := @428 (fun (ro : @427) => @900) +@904 := @428 (fun (__e_ro : @427) => @900) +@909 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@910 := (__e_hrep : @909) -> @904 +@911 := fun (__e_hrep : @909) => @894 +@912 := (b : @3) -> @910 +@913 := fun (b : @3) => @911 +@914 := (a : @3) -> @912 +@915 := fun (a : @3) => @913 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustStd.lean deleted file mode 100644 index a9d80c2f3..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Nat) (b : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustStd.lex.tex new file mode 100644 index 000000000..bee67bbfe --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustStd.lex.tex @@ -0,0 +1,462 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd.root : @914 := @915 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@65 := Prod.{0, 0} @3 @54 +@66 := 1 +@69 := Prod.mk.{0, 0} @3 @54 +@70 := @69 @66 +@71 := @70 @50 +@72 := 0 +@73 := @69 @72 +@74 := @73 @6 +@75 := @55 @65 +@76 := @56 @65 +@78 := @76 @74 @75 +@80 := @76 @71 @78 +@81 := Bool.true +@82 := LexLeanTarget.TargetSyntax.Function +@83 := LexLeanTarget.TargetSyntax.Program.functions +@84 := @83 @0 +@85 := LexLeanTarget.TargetSyntax.Ty +@86 := @55 @3 +@87 := @55 @85 +@88 := LexLeanTarget.TargetSyntax.Ty.unit +@89 := LexLeanTarget.TargetSyntax.Value.unit +@92 := LexLeanTarget.TargetSyntax.Expr.value @88 @89 +@97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 +@102 := List.getD.{0} @82 @84 @72 @97 +@106 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd.root @17 @72 +@107 := LexLeanPreservation.Rust.WTL +@115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 +@117 := LexLeanPreservation.Rust.wtl_nil @0 +@118 := @107 @0 +@124 := {c : @9} -> {A : @10} -> @118 @15 @17 @57 @87 +@125 := @117 @1 +@126 := @118 @1 +@130 := {A : @10} -> @126 @17 @57 @87 +@131 := @125 @2 +@132 := @126 @2 +@133 := @132 @57 +@134 := @133 @87 +@135 := List.{0} +@136 := @135 @54 +@137 := @135 @85 +@138 := #6 +@139 := @11 @138 +@140 := #5 +@141 := @139 @140 +@142 := #4 +@145 := @141 @142 @12 @4 +@146 := #7 +@151 := @107 @146 @138 @140 @4 @15 +@152 := #8 +@155 := @107 @152 @146 @138 +@157 := @58 @140 @12 +@158 := @155 @157 +@159 := @56 @85 +@161 := @159 @142 @4 +@171 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @145) -> (hs : @151) -> @158 @161 +@173 := LexLeanPreservation.Rust.wtl_cons @0 +@193 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> + (h : @27 @140 @142 @12 @4) -> (hs : @118 @138 @140 @4 @15) -> @118 @146 @138 @157 @161 +@194 := @173 @1 +@210 := {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> (h : @36 @142 @12 @4) -> (hs : @126 @140 @4 @15) -> @126 @138 @157 @161 +@211 := @194 @2 +@213 := @43 @12 @4 +@215 := @132 @4 @15 +@223 := {v : @54} -> + {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @213) -> (hs : @215) -> @132 @157 @161 +@224 := @211 @50 +@225 := @5 @142 +@226 := @43 @225 +@227 := @226 @4 +@228 := @5 @138 +@229 := @58 @228 +@231 := @132 (@229 @12) +@237 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @227) -> (hs : @215) -> @231 @161 +@238 := @224 @7 +@239 := @5 @12 +@241 := @43 @239 @7 +@242 := @5 @140 +@243 := @58 @242 +@245 := @132 (@243 @12) +@246 := @159 @7 +@247 := @246 @4 +@252 := {vs : @136} -> {ts : @137} -> (h : @241) -> (hs : @215) -> @245 @247 +@253 := @238 @57 +@254 := @133 @15 +@255 := @58 @225 +@256 := @255 @57 +@261 := {ts : @137} -> (h : @49) -> (hs : @254) -> @132 @256 @247 +@262 := @253 @87 +@263 := @58 @239 +@264 := @263 @57 +@265 := @132 @264 +@266 := @246 @87 +@269 := (h : @53) -> (hs : @134) -> @265 @266 +@270 := @262 @51 +@271 := @61 @57 +@273 := @132 @271 @266 +@274 := (hs : @134) -> @273 +@275 := @270 @131 +@277 := @132 @60 @266 +@278 := @211 @6 +@280 := @43 @242 @4 +@281 := @5 @146 +@282 := @58 @281 +@290 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @280) -> (hs : @215) -> @132 (@282 @12) @161 +@291 := @278 @7 +@297 := {vs : @136} -> {ts : @137} -> (h : @226 @7) -> (hs : @215) -> @231 @247 +@298 := @291 @60 +@299 := @265 @15 +@300 := @243 @256 +@301 := @132 @300 +@305 := {ts : @137} -> (h : @241) -> (hs : @299) -> @301 @247 +@306 := @298 @266 +@307 := @255 @264 +@308 := @132 @307 +@309 := @246 @266 +@312 := (h : @49) -> (hs : @273) -> @308 @309 +@313 := @306 @47 +@314 := @263 @271 +@315 := @132 @314 +@317 := (hs : @277) -> @315 @309 +@318 := @313 @275 +@319 := @132 @62 +@320 := @319 @309 +@321 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.__fits_0 +@326 := @324 @4 @15 +@330 := @5 (Coverage.Main.natOps @4 @15) +@333 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.root @4 @15 +@334 := Bool +@335 := Ne.{1} +@336 := LexLeanPreservation.Obs +@337 := @335 @336 +@338 := LexLeanPreservation.Rel +@341 := @337 (@338 @15 @17) +@342 := LexLeanPreservation.Obs.stuck +@345 := (f : @334) -> (v : @54) -> @341 @342 +@347 := LexLeanPreservation.Rust.rel_ne_stuck @326 +@354 := (v : @54) -> @337 (@338 (@324 @12 @4) @17) @342 +@355 := @347 @330 +@359 := @337 (@338 @326 @330) @342 +@360 := @135 @65 +@361 := LexLeanPreservation.Rust.FunSem +@362 := #9 +@368 := (n : @3) -> @361 @362 @152 @146 @17 @138 +@369 := Eq.{1} +@370 := Option.{0} +@371 := @370 @82 +@372 := @369 @371 +@379 := LexLeanRuntime.index (@135 @82) @82 (LexLeanRuntime.instIndexableList @82) +@383 := @372 (@379 (@83 @362) @138) +@384 := Option.some.{0} +@385 := @384 @82 +@386 := @385 @140 +@387 := @383 @386 +@388 := #10 +@392 := @107 @388 @362 @152 @140 +@393 := LexLeanTarget.TargetSyntax.Function.types +@394 := @393 @138 +@395 := @392 @394 +@396 := @370 @360 +@397 := @369 @396 +@398 := LexLeanTarget.TargetSemantics.bindAll +@399 := LexLeanTarget.TargetSyntax.Function.parameters +@404 := @397 (@398 (@399 @146) @138 @75) +@405 := @384 @360 +@406 := @405 @140 +@407 := @404 @406 +@408 := @370 @334 +@409 := @369 @408 +@410 := LexLeanPreservation.Rust.fnFallible +@411 := #11 +@414 := @409 (@410 @411 @362) +@415 := @384 @334 +@416 := @415 @140 +@417 := @414 @416 +@418 := LexLeanPreservation.RunConv +@419 := #13 +@423 := @418 @419 @388 @152 @140 +@425 := @337 @138 @342 +@426 := Exists.{1} +@427 := LexLeanPreservation.Rust.ROut +@428 := @426 @427 +@429 := And +@430 := LexLeanPreservation.Rust.RealizesFn +@434 := @429 (@430 @362 @152 @17) +@435 := LexLeanPreservation.Rust.RCI +@437 := @435 #15 +@438 := LexLeanPreservation.Rust.fnIdent +@439 := @438 @419 +@446 := (hne : @425) -> @428 (fun (ro : @427) => @434 (@437 @439 @411 @17)) +@461 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @368) -> + (hfn : @387) -> (hwt : @395) -> (hbind : @407) -> (hF : @417) -> (hA : @423) -> @446 +@463 := LexLeanPreservation.Rust.compose @0 +@464 := @361 @0 +@469 := (n : @3) -> @464 @152 @146 @17 @138 +@470 := @379 @84 +@473 := @372 (@470 @138) @386 +@477 := @118 @362 @152 @140 @394 +@478 := @418 @0 +@481 := @478 @388 @152 @140 +@495 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @469) -> + (hfn : @473) -> (hwt : @477) -> (hbind : @407) -> (hF : @417) -> (hA : @481) -> @446 +@496 := @463 @1 +@497 := @464 @1 +@501 := (n : @3) -> @497 @146 @17 @138 +@504 := @126 @152 @140 @394 +@505 := @410 @1 +@508 := @409 (@505 @362) @416 +@509 := @435 @1 +@519 := (hbind : @407) -> + (hF : @508) -> (hA : @481) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@509 @439 @411 @17)) +@529 := {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> {F : @334} -> {o : @336} -> (hB : @501) -> (hfn : @473) -> (hwt : @504) -> @519 +@530 := @496 @2 +@532 := @497 @2 @17 +@534 := (n : @3) -> @532 @138 +@535 := @132 @140 +@536 := @535 @394 +@545 := {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> {F : @334} -> {o : @336} -> (hB : @534) -> (hfn : @473) -> (hwt : @536) -> @519 +@546 := @530 @72 +@548 := (n : @3) -> @532 @72 +@549 := @470 @72 +@550 := @372 @549 +@551 := @550 @386 +@552 := @505 @72 +@553 := @409 @552 +@554 := @553 @416 +@555 := @478 @72 +@557 := @555 @152 @140 +@559 := @509 (@438 @72) +@567 := (hF : @554) -> (hA : @557) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 @411 @17)) +@576 := {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> {o : @336} -> (hB : @548) -> (hfn : @551) -> (hwt : @536) -> (hbind : @407) -> @567 +@577 := @546 @102 +@579 := @550 (@385 @102) +@580 := @393 @102 +@581 := @535 @580 +@583 := @398 (@399 @102) +@595 := {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @548) -> (hfn : @579) -> (hwt : @581) -> (hbind : @397 (@583 @138 @75) @406) -> @567 +@596 := @577 @62 +@598 := @282 (@229 @57) +@600 := @132 @598 @580 +@602 := @58 (@5 @152) +@604 := @602 (@282 @57) +@608 := @397 (@583 @604 @75) @406 +@610 := @58 (@5 @388) +@612 := @58 (@5 @362) +@614 := @610 (@612 @57) +@616 := @555 @614 @140 +@618 := @58 (@5 @419) +@621 := @58 (@5 #12) +@638 := {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @600) -> + (hbind : @608) -> + (hF : @554) -> + (hA : @616) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 (@618 (@621 @57)) @17)) +@639 := @596 @80 +@641 := @229 (@243 @57) +@643 := @132 @641 @580 +@654 := @397 (@583 @598 @75) (@405 (@76 (@70 @228) (@76 (@73 @281) @75))) +@656 := @612 (@602 @57) +@658 := @555 @656 @140 +@660 := @58 (@5 @411) +@676 := {F : @334} -> + {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @643) -> + (hbind : @654) -> + (hF : @554) -> + (hA : @658) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 (@621 (@660 @57)) @17)) +@677 := @639 @81 +@678 := @301 @580 +@689 := @397 (@583 @641 @75) (@405 (@76 (@70 @242) (@76 (@73 @228) @75))) +@691 := @553 (@415 @81) +@693 := @555 @604 @140 +@694 := @430 @81 +@712 := {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @678) -> + (hbind : @689) -> + (hF : @691) -> + (hA : @693) -> + (hne : @425) -> @428 (fun (ro : @427) => @429 (@694 @152 @17) (@559 (@660 (@610 @57)) @17)) +@713 := @677 @323 +@714 := @308 @580 +@725 := @397 (@583 @300 @75) (@405 (@76 (@70 @225) (@76 (@73 @242) @75))) +@726 := @555 @598 +@728 := @321 @146 @138 +@729 := @726 @728 +@731 := @321 @152 @146 +@750 := (hB : @548) -> + (hfn : @579) -> + (hwt : @714) -> + (hbind : @725) -> + (hF : @691) -> + (hA : @729) -> + (hne : @337 @731 @342) -> + @428 (fun (ro : @427) => @429 (@694 (@321 @388 @362) @17) (@559 @614 @17)) +@751 := @713 @106 +@752 := @315 @580 +@763 := @397 (@583 @307 @75) (@405 (@76 (@70 @239) (@76 (@73 @225) @75))) +@764 := @555 @641 +@766 := @321 @138 @140 +@785 := (hfn : @579) -> + (hwt : @752) -> + (hbind : @763) -> + (hF : @691) -> + (hA : @764 @766) -> + (hne : @337 @728 @342) -> + @428 (fun (ro : @427) => @429 (@694 (@321 @362 @152) @17) (@559 @656 @17)) +@786 := Eq.refl.{1} +@789 := @751 (@786 @371 @549) +@790 := @319 @580 +@801 := @397 (@583 @314 @75) (@405 (@76 (@70 @6) (@76 (@73 @239) @75))) +@802 := @555 @300 +@804 := @321 @140 @142 +@820 := (hwt : @790) -> + (hbind : @801) -> + (hF : @691) -> + (hA : @802 @804) -> + (hne : @337 @766 @342) -> @428 (fun (ro : @427) => @429 (@694 @731 @17) (@559 @604 @17)) +@821 := @789 @318 +@823 := @583 @62 @75 +@826 := @397 @823 (@405 @80) +@827 := @555 @307 +@829 := @321 @142 @12 +@844 := (hbind : @826) -> + (hF : @691) -> + (hA : @827 @829) -> + (hne : @337 @804 @342) -> @428 (fun (ro : @427) => @429 (@694 @728 @17) (@559 @598 @17)) +@847 := @821 (@786 @396 @823) +@848 := @555 @314 +@850 := @321 @12 @4 +@864 := (hF : @691) -> + (hA : @848 @850) -> + (hne : @337 @829 @342) -> @428 (fun (ro : @427) => @429 (@694 @766 @17) (@559 @641 @17)) +@867 := @847 (@786 @408 @552) +@881 := (hA : @555 @62 @323) -> + (hne : @337 @850 @342) -> @428 (fun (ro : @427) => @429 (@694 @804 @17) (@559 @300 @17)) +@882 := @867 @333 +@893 := (hne : @337 @323 @342) -> @428 (fun (ro : @427) => @429 (@694 @829 @17) (@559 @307 @17)) +@894 := @882 @355 +@900 := @429 (@694 @850 @17) (@559 @314 @17) +@902 := @428 (fun (ro : @427) => @900) +@904 := @428 (fun (__e_ro : @427) => @900) +@909 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@910 := (__e_hrep : @909) -> @904 +@911 := fun (__e_hrep : @909) => @894 +@912 := (b : @3) -> @910 +@913 := fun (b : @3) => @911 +@914 := (a : @3) -> @912 +@915 := fun (a : @3) => @913 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustCore.lean deleted file mode 100644 index aa129a8ad..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int) (b : Int) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.int b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.int b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_int a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_int b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustCore.lex.tex new file mode 100644 index 000000000..3e3921eea --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustCore.lex.tex @@ -0,0 +1,463 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore.root : @915 := @916 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore.flags +@3 := Int +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.int +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.int +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_int @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@63 := Nat +@66 := Prod.{0, 0} @63 @54 +@67 := 1 +@70 := Prod.mk.{0, 0} @63 @54 +@71 := @70 @67 +@72 := @71 @50 +@73 := 0 +@74 := @70 @73 +@75 := @74 @6 +@76 := @55 @66 +@77 := @56 @66 +@79 := @77 @75 @76 +@81 := @77 @72 @79 +@82 := Bool.true +@83 := LexLeanTarget.TargetSyntax.Function +@84 := LexLeanTarget.TargetSyntax.Program.functions +@85 := @84 @0 +@86 := LexLeanTarget.TargetSyntax.Ty +@87 := @55 @63 +@88 := @55 @86 +@89 := LexLeanTarget.TargetSyntax.Ty.unit +@90 := LexLeanTarget.TargetSyntax.Value.unit +@93 := LexLeanTarget.TargetSyntax.Expr.value @89 @90 +@98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 +@103 := List.getD.{0} @83 @85 @73 @98 +@107 := fun (__e_n : @63) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore.root @17 @73 +@108 := LexLeanPreservation.Rust.WTL +@116 := {p : @8} -> {c : @9} -> {A : @10} -> @108 @4 @15 @17 @57 @88 +@118 := LexLeanPreservation.Rust.wtl_nil @0 +@119 := @108 @0 +@125 := {c : @9} -> {A : @10} -> @119 @15 @17 @57 @88 +@126 := @118 @1 +@127 := @119 @1 +@131 := {A : @10} -> @127 @17 @57 @88 +@132 := @126 @2 +@133 := @127 @2 +@134 := @133 @57 +@135 := @134 @88 +@136 := List.{0} +@137 := @136 @54 +@138 := @136 @86 +@139 := #6 +@140 := @11 @139 +@141 := #5 +@142 := @140 @141 +@143 := #4 +@146 := @142 @143 @12 @4 +@147 := #7 +@152 := @108 @147 @139 @141 @4 @15 +@153 := #8 +@156 := @108 @153 @147 @139 +@158 := @58 @141 @12 +@159 := @156 @158 +@160 := @56 @86 +@162 := @160 @143 @4 +@172 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @146) -> (hs : @152) -> @159 @162 +@174 := LexLeanPreservation.Rust.wtl_cons @0 +@194 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> + (h : @27 @141 @143 @12 @4) -> (hs : @119 @139 @141 @4 @15) -> @119 @147 @139 @158 @162 +@195 := @174 @1 +@211 := {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> (h : @36 @143 @12 @4) -> (hs : @127 @141 @4 @15) -> @127 @139 @158 @162 +@212 := @195 @2 +@214 := @43 @12 @4 +@216 := @133 @4 @15 +@224 := {v : @54} -> + {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @214) -> (hs : @216) -> @133 @158 @162 +@225 := @212 @50 +@226 := @5 @143 +@227 := @43 @226 +@228 := @227 @4 +@229 := @5 @139 +@230 := @58 @229 +@232 := @133 (@230 @12) +@238 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @228) -> (hs : @216) -> @232 @162 +@239 := @225 @7 +@240 := @5 @12 +@242 := @43 @240 @7 +@243 := @5 @141 +@244 := @58 @243 +@246 := @133 (@244 @12) +@247 := @160 @7 +@248 := @247 @4 +@253 := {vs : @137} -> {ts : @138} -> (h : @242) -> (hs : @216) -> @246 @248 +@254 := @239 @57 +@255 := @134 @15 +@256 := @58 @226 +@257 := @256 @57 +@262 := {ts : @138} -> (h : @49) -> (hs : @255) -> @133 @257 @248 +@263 := @254 @88 +@264 := @58 @240 +@265 := @264 @57 +@266 := @133 @265 +@267 := @247 @88 +@270 := (h : @53) -> (hs : @135) -> @266 @267 +@271 := @263 @51 +@272 := @61 @57 +@274 := @133 @272 @267 +@275 := (hs : @135) -> @274 +@276 := @271 @132 +@278 := @133 @60 @267 +@279 := @212 @6 +@281 := @43 @243 @4 +@282 := @5 @147 +@283 := @58 @282 +@291 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @281) -> (hs : @216) -> @133 (@283 @12) @162 +@292 := @279 @7 +@298 := {vs : @137} -> {ts : @138} -> (h : @227 @7) -> (hs : @216) -> @232 @248 +@299 := @292 @60 +@300 := @266 @15 +@301 := @244 @257 +@302 := @133 @301 +@306 := {ts : @138} -> (h : @242) -> (hs : @300) -> @302 @248 +@307 := @299 @267 +@308 := @256 @265 +@309 := @133 @308 +@310 := @247 @267 +@313 := (h : @49) -> (hs : @274) -> @309 @310 +@314 := @307 @47 +@315 := @264 @272 +@316 := @133 @315 +@318 := (hs : @278) -> @316 @310 +@319 := @314 @276 +@320 := @133 @62 +@321 := @320 @310 +@322 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.denote +@324 := @322 @4 @15 +@325 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.__fits_0 +@327 := @325 @4 @15 +@331 := @5 (Coverage.Main.intOps @4 @15) +@334 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.root @4 @15 +@335 := Bool +@336 := Ne.{1} +@337 := LexLeanPreservation.Obs +@338 := @336 @337 +@339 := LexLeanPreservation.Rel +@342 := @338 (@339 @15 @17) +@343 := LexLeanPreservation.Obs.stuck +@346 := (f : @335) -> (v : @54) -> @342 @343 +@348 := LexLeanPreservation.Rust.rel_ne_stuck @327 +@355 := (v : @54) -> @338 (@339 (@325 @12 @4) @17) @343 +@356 := @348 @331 +@360 := @338 (@339 @327 @331) @343 +@361 := @136 @66 +@362 := LexLeanPreservation.Rust.FunSem +@363 := #9 +@369 := (n : @63) -> @362 @363 @153 @147 @17 @139 +@370 := Eq.{1} +@371 := Option.{0} +@372 := @371 @83 +@373 := @370 @372 +@380 := LexLeanRuntime.index (@136 @83) @83 (LexLeanRuntime.instIndexableList @83) +@384 := @373 (@380 (@84 @363) @139) +@385 := Option.some.{0} +@386 := @385 @83 +@387 := @386 @141 +@388 := @384 @387 +@389 := #10 +@393 := @108 @389 @363 @153 @141 +@394 := LexLeanTarget.TargetSyntax.Function.types +@395 := @394 @139 +@396 := @393 @395 +@397 := @371 @361 +@398 := @370 @397 +@399 := LexLeanTarget.TargetSemantics.bindAll +@400 := LexLeanTarget.TargetSyntax.Function.parameters +@405 := @398 (@399 (@400 @147) @139 @76) +@406 := @385 @361 +@407 := @406 @141 +@408 := @405 @407 +@409 := @371 @335 +@410 := @370 @409 +@411 := LexLeanPreservation.Rust.fnFallible +@412 := #11 +@415 := @410 (@411 @412 @363) +@416 := @385 @335 +@417 := @416 @141 +@418 := @415 @417 +@419 := LexLeanPreservation.RunConv +@420 := #13 +@424 := @419 @420 @389 @153 @141 +@426 := @338 @139 @343 +@427 := Exists.{1} +@428 := LexLeanPreservation.Rust.ROut +@429 := @427 @428 +@430 := And +@431 := LexLeanPreservation.Rust.RealizesFn +@435 := @430 (@431 @363 @153 @17) +@436 := LexLeanPreservation.Rust.RCI +@438 := @436 #15 +@439 := LexLeanPreservation.Rust.fnIdent +@440 := @439 @420 +@447 := (hne : @426) -> @429 (fun (ro : @428) => @435 (@438 @440 @412 @17)) +@462 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @361} -> + {F : @335} -> + {o : @337} -> + (hB : @369) -> + (hfn : @388) -> (hwt : @396) -> (hbind : @408) -> (hF : @418) -> (hA : @424) -> @447 +@464 := LexLeanPreservation.Rust.compose @0 +@465 := @362 @0 +@470 := (n : @63) -> @465 @153 @147 @17 @139 +@471 := @380 @85 +@474 := @373 (@471 @139) @387 +@478 := @119 @363 @153 @141 @395 +@479 := @419 @0 +@482 := @479 @389 @153 @141 +@496 := {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @361} -> + {F : @335} -> + {o : @337} -> + (hB : @470) -> + (hfn : @474) -> (hwt : @478) -> (hbind : @408) -> (hF : @418) -> (hA : @482) -> @447 +@497 := @464 @1 +@498 := @465 @1 +@502 := (n : @63) -> @498 @147 @17 @139 +@505 := @127 @153 @141 @395 +@506 := @411 @1 +@509 := @410 (@506 @363) @417 +@510 := @436 @1 +@520 := (hbind : @408) -> + (hF : @509) -> (hA : @482) -> (hne : @426) -> @429 (fun (ro : @428) => @435 (@510 @440 @412 @17)) +@530 := {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @361} -> {F : @335} -> {o : @337} -> (hB : @502) -> (hfn : @474) -> (hwt : @505) -> @520 +@531 := @497 @2 +@533 := @498 @2 @17 +@535 := (n : @63) -> @533 @139 +@536 := @133 @141 +@537 := @536 @395 +@546 := {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @361} -> {F : @335} -> {o : @337} -> (hB : @535) -> (hfn : @474) -> (hwt : @537) -> @520 +@547 := @531 @73 +@549 := (n : @63) -> @533 @73 +@550 := @471 @73 +@551 := @373 @550 +@552 := @551 @387 +@553 := @506 @73 +@554 := @410 @553 +@555 := @554 @417 +@556 := @479 @73 +@558 := @556 @153 @141 +@560 := @510 (@439 @73) +@568 := (hF : @555) -> (hA : @558) -> (hne : @426) -> @429 (fun (ro : @428) => @435 (@560 @412 @17)) +@577 := {fn : @83} -> + {args : @137} -> + {env : @361} -> + {F : @335} -> {o : @337} -> (hB : @549) -> (hfn : @552) -> (hwt : @537) -> (hbind : @408) -> @568 +@578 := @547 @103 +@580 := @551 (@386 @103) +@581 := @394 @103 +@582 := @536 @581 +@584 := @399 (@400 @103) +@596 := {args : @137} -> + {env : @361} -> + {F : @335} -> + {o : @337} -> + (hB : @549) -> (hfn : @580) -> (hwt : @582) -> (hbind : @398 (@584 @139 @76) @407) -> @568 +@597 := @578 @62 +@599 := @283 (@230 @57) +@601 := @133 @599 @581 +@603 := @58 (@5 @153) +@605 := @603 (@283 @57) +@609 := @398 (@584 @605 @76) @407 +@611 := @58 (@5 @389) +@613 := @58 (@5 @363) +@615 := @611 (@613 @57) +@617 := @556 @615 @141 +@619 := @58 (@5 @420) +@622 := @58 (@5 #12) +@639 := {env : @361} -> + {F : @335} -> + {o : @337} -> + (hB : @549) -> + (hfn : @580) -> + (hwt : @601) -> + (hbind : @609) -> + (hF : @555) -> + (hA : @617) -> (hne : @426) -> @429 (fun (ro : @428) => @435 (@560 (@619 (@622 @57)) @17)) +@640 := @597 @81 +@642 := @230 (@244 @57) +@644 := @133 @642 @581 +@655 := @398 (@584 @599 @76) (@406 (@77 (@71 @229) (@77 (@74 @282) @76))) +@657 := @613 (@603 @57) +@659 := @556 @657 @141 +@661 := @58 (@5 @412) +@677 := {F : @335} -> + {o : @337} -> + (hB : @549) -> + (hfn : @580) -> + (hwt : @644) -> + (hbind : @655) -> + (hF : @555) -> + (hA : @659) -> (hne : @426) -> @429 (fun (ro : @428) => @435 (@560 (@622 (@661 @57)) @17)) +@678 := @640 @82 +@679 := @302 @581 +@690 := @398 (@584 @642 @76) (@406 (@77 (@71 @243) (@77 (@74 @229) @76))) +@692 := @554 (@416 @82) +@694 := @556 @605 @141 +@695 := @431 @82 +@713 := {o : @337} -> + (hB : @549) -> + (hfn : @580) -> + (hwt : @679) -> + (hbind : @690) -> + (hF : @692) -> + (hA : @694) -> + (hne : @426) -> @429 (fun (ro : @428) => @430 (@695 @153 @17) (@560 (@661 (@611 @57)) @17)) +@714 := @678 @324 +@715 := @309 @581 +@726 := @398 (@584 @301 @76) (@406 (@77 (@71 @226) (@77 (@74 @243) @76))) +@727 := @556 @599 +@729 := @322 @147 @139 +@730 := @727 @729 +@732 := @322 @153 @147 +@751 := (hB : @549) -> + (hfn : @580) -> + (hwt : @715) -> + (hbind : @726) -> + (hF : @692) -> + (hA : @730) -> + (hne : @338 @732 @343) -> + @429 (fun (ro : @428) => @430 (@695 (@322 @389 @363) @17) (@560 @615 @17)) +@752 := @714 @107 +@753 := @316 @581 +@764 := @398 (@584 @308 @76) (@406 (@77 (@71 @240) (@77 (@74 @226) @76))) +@765 := @556 @642 +@767 := @322 @139 @141 +@786 := (hfn : @580) -> + (hwt : @753) -> + (hbind : @764) -> + (hF : @692) -> + (hA : @765 @767) -> + (hne : @338 @729 @343) -> + @429 (fun (ro : @428) => @430 (@695 (@322 @363 @153) @17) (@560 @657 @17)) +@787 := Eq.refl.{1} +@790 := @752 (@787 @372 @550) +@791 := @320 @581 +@802 := @398 (@584 @315 @76) (@406 (@77 (@71 @6) (@77 (@74 @240) @76))) +@803 := @556 @301 +@805 := @322 @141 @143 +@821 := (hwt : @791) -> + (hbind : @802) -> + (hF : @692) -> + (hA : @803 @805) -> + (hne : @338 @767 @343) -> @429 (fun (ro : @428) => @430 (@695 @732 @17) (@560 @605 @17)) +@822 := @790 @319 +@824 := @584 @62 @76 +@827 := @398 @824 (@406 @81) +@828 := @556 @308 +@830 := @322 @143 @12 +@845 := (hbind : @827) -> + (hF : @692) -> + (hA : @828 @830) -> + (hne : @338 @805 @343) -> @429 (fun (ro : @428) => @430 (@695 @729 @17) (@560 @599 @17)) +@848 := @822 (@787 @397 @824) +@849 := @556 @315 +@851 := @322 @12 @4 +@865 := (hF : @692) -> + (hA : @849 @851) -> + (hne : @338 @830 @343) -> @429 (fun (ro : @428) => @430 (@695 @767 @17) (@560 @642 @17)) +@868 := @848 (@787 @409 @553) +@882 := (hA : @556 @62 @324) -> + (hne : @338 @851 @343) -> @429 (fun (ro : @428) => @430 (@695 @805 @17) (@560 @301 @17)) +@883 := @868 @334 +@894 := (hne : @338 @324 @343) -> @429 (fun (ro : @428) => @430 (@695 @830 @17) (@560 @308 @17)) +@895 := @883 @356 +@901 := @430 (@695 @851 @17) (@560 @315 @17) +@903 := @429 (fun (ro : @428) => @901) +@905 := @429 (fun (__e_ro : @428) => @901) +@910 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@911 := (__e_hrep : @910) -> @905 +@912 := fun (__e_hrep : @910) => @895 +@913 := (b : @3) -> @911 +@914 := fun (b : @3) => @912 +@915 := (a : @3) -> @913 +@916 := fun (a : @3) => @914 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustStd.lean deleted file mode 100644 index 835b954dc..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int) (b : Int) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.int b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.int b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_int a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_int b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustStd.lex.tex new file mode 100644 index 000000000..8bacfced2 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustStd.lex.tex @@ -0,0 +1,463 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd.root : @915 := @916 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd.flags +@3 := Int +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.int +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.int +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_int @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@63 := Nat +@66 := Prod.{0, 0} @63 @54 +@67 := 1 +@70 := Prod.mk.{0, 0} @63 @54 +@71 := @70 @67 +@72 := @71 @50 +@73 := 0 +@74 := @70 @73 +@75 := @74 @6 +@76 := @55 @66 +@77 := @56 @66 +@79 := @77 @75 @76 +@81 := @77 @72 @79 +@82 := Bool.true +@83 := LexLeanTarget.TargetSyntax.Function +@84 := LexLeanTarget.TargetSyntax.Program.functions +@85 := @84 @0 +@86 := LexLeanTarget.TargetSyntax.Ty +@87 := @55 @63 +@88 := @55 @86 +@89 := LexLeanTarget.TargetSyntax.Ty.unit +@90 := LexLeanTarget.TargetSyntax.Value.unit +@93 := LexLeanTarget.TargetSyntax.Expr.value @89 @90 +@98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 +@103 := List.getD.{0} @83 @85 @73 @98 +@107 := fun (__e_n : @63) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd.root @17 @73 +@108 := LexLeanPreservation.Rust.WTL +@116 := {p : @8} -> {c : @9} -> {A : @10} -> @108 @4 @15 @17 @57 @88 +@118 := LexLeanPreservation.Rust.wtl_nil @0 +@119 := @108 @0 +@125 := {c : @9} -> {A : @10} -> @119 @15 @17 @57 @88 +@126 := @118 @1 +@127 := @119 @1 +@131 := {A : @10} -> @127 @17 @57 @88 +@132 := @126 @2 +@133 := @127 @2 +@134 := @133 @57 +@135 := @134 @88 +@136 := List.{0} +@137 := @136 @54 +@138 := @136 @86 +@139 := #6 +@140 := @11 @139 +@141 := #5 +@142 := @140 @141 +@143 := #4 +@146 := @142 @143 @12 @4 +@147 := #7 +@152 := @108 @147 @139 @141 @4 @15 +@153 := #8 +@156 := @108 @153 @147 @139 +@158 := @58 @141 @12 +@159 := @156 @158 +@160 := @56 @86 +@162 := @160 @143 @4 +@172 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @146) -> (hs : @152) -> @159 @162 +@174 := LexLeanPreservation.Rust.wtl_cons @0 +@194 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> + (h : @27 @141 @143 @12 @4) -> (hs : @119 @139 @141 @4 @15) -> @119 @147 @139 @158 @162 +@195 := @174 @1 +@211 := {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> (h : @36 @143 @12 @4) -> (hs : @127 @141 @4 @15) -> @127 @139 @158 @162 +@212 := @195 @2 +@214 := @43 @12 @4 +@216 := @133 @4 @15 +@224 := {v : @54} -> + {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @214) -> (hs : @216) -> @133 @158 @162 +@225 := @212 @50 +@226 := @5 @143 +@227 := @43 @226 +@228 := @227 @4 +@229 := @5 @139 +@230 := @58 @229 +@232 := @133 (@230 @12) +@238 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @228) -> (hs : @216) -> @232 @162 +@239 := @225 @7 +@240 := @5 @12 +@242 := @43 @240 @7 +@243 := @5 @141 +@244 := @58 @243 +@246 := @133 (@244 @12) +@247 := @160 @7 +@248 := @247 @4 +@253 := {vs : @137} -> {ts : @138} -> (h : @242) -> (hs : @216) -> @246 @248 +@254 := @239 @57 +@255 := @134 @15 +@256 := @58 @226 +@257 := @256 @57 +@262 := {ts : @138} -> (h : @49) -> (hs : @255) -> @133 @257 @248 +@263 := @254 @88 +@264 := @58 @240 +@265 := @264 @57 +@266 := @133 @265 +@267 := @247 @88 +@270 := (h : @53) -> (hs : @135) -> @266 @267 +@271 := @263 @51 +@272 := @61 @57 +@274 := @133 @272 @267 +@275 := (hs : @135) -> @274 +@276 := @271 @132 +@278 := @133 @60 @267 +@279 := @212 @6 +@281 := @43 @243 @4 +@282 := @5 @147 +@283 := @58 @282 +@291 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @281) -> (hs : @216) -> @133 (@283 @12) @162 +@292 := @279 @7 +@298 := {vs : @137} -> {ts : @138} -> (h : @227 @7) -> (hs : @216) -> @232 @248 +@299 := @292 @60 +@300 := @266 @15 +@301 := @244 @257 +@302 := @133 @301 +@306 := {ts : @138} -> (h : @242) -> (hs : @300) -> @302 @248 +@307 := @299 @267 +@308 := @256 @265 +@309 := @133 @308 +@310 := @247 @267 +@313 := (h : @49) -> (hs : @274) -> @309 @310 +@314 := @307 @47 +@315 := @264 @272 +@316 := @133 @315 +@318 := (hs : @278) -> @316 @310 +@319 := @314 @276 +@320 := @133 @62 +@321 := @320 @310 +@322 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.denote +@324 := @322 @4 @15 +@325 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.__fits_0 +@327 := @325 @4 @15 +@331 := @5 (Coverage.Main.intOps @4 @15) +@334 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.root @4 @15 +@335 := Bool +@336 := Ne.{1} +@337 := LexLeanPreservation.Obs +@338 := @336 @337 +@339 := LexLeanPreservation.Rel +@342 := @338 (@339 @15 @17) +@343 := LexLeanPreservation.Obs.stuck +@346 := (f : @335) -> (v : @54) -> @342 @343 +@348 := LexLeanPreservation.Rust.rel_ne_stuck @327 +@355 := (v : @54) -> @338 (@339 (@325 @12 @4) @17) @343 +@356 := @348 @331 +@360 := @338 (@339 @327 @331) @343 +@361 := @136 @66 +@362 := LexLeanPreservation.Rust.FunSem +@363 := #9 +@369 := (n : @63) -> @362 @363 @153 @147 @17 @139 +@370 := Eq.{1} +@371 := Option.{0} +@372 := @371 @83 +@373 := @370 @372 +@380 := LexLeanRuntime.index (@136 @83) @83 (LexLeanRuntime.instIndexableList @83) +@384 := @373 (@380 (@84 @363) @139) +@385 := Option.some.{0} +@386 := @385 @83 +@387 := @386 @141 +@388 := @384 @387 +@389 := #10 +@393 := @108 @389 @363 @153 @141 +@394 := LexLeanTarget.TargetSyntax.Function.types +@395 := @394 @139 +@396 := @393 @395 +@397 := @371 @361 +@398 := @370 @397 +@399 := LexLeanTarget.TargetSemantics.bindAll +@400 := LexLeanTarget.TargetSyntax.Function.parameters +@405 := @398 (@399 (@400 @147) @139 @76) +@406 := @385 @361 +@407 := @406 @141 +@408 := @405 @407 +@409 := @371 @335 +@410 := @370 @409 +@411 := LexLeanPreservation.Rust.fnFallible +@412 := #11 +@415 := @410 (@411 @412 @363) +@416 := @385 @335 +@417 := @416 @141 +@418 := @415 @417 +@419 := LexLeanPreservation.RunConv +@420 := #13 +@424 := @419 @420 @389 @153 @141 +@426 := @338 @139 @343 +@427 := Exists.{1} +@428 := LexLeanPreservation.Rust.ROut +@429 := @427 @428 +@430 := And +@431 := LexLeanPreservation.Rust.RealizesFn +@435 := @430 (@431 @363 @153 @17) +@436 := LexLeanPreservation.Rust.RCI +@438 := @436 #15 +@439 := LexLeanPreservation.Rust.fnIdent +@440 := @439 @420 +@447 := (hne : @426) -> @429 (fun (ro : @428) => @435 (@438 @440 @412 @17)) +@462 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @361} -> + {F : @335} -> + {o : @337} -> + (hB : @369) -> + (hfn : @388) -> (hwt : @396) -> (hbind : @408) -> (hF : @418) -> (hA : @424) -> @447 +@464 := LexLeanPreservation.Rust.compose @0 +@465 := @362 @0 +@470 := (n : @63) -> @465 @153 @147 @17 @139 +@471 := @380 @85 +@474 := @373 (@471 @139) @387 +@478 := @119 @363 @153 @141 @395 +@479 := @419 @0 +@482 := @479 @389 @153 @141 +@496 := {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @361} -> + {F : @335} -> + {o : @337} -> + (hB : @470) -> + (hfn : @474) -> (hwt : @478) -> (hbind : @408) -> (hF : @418) -> (hA : @482) -> @447 +@497 := @464 @1 +@498 := @465 @1 +@502 := (n : @63) -> @498 @147 @17 @139 +@505 := @127 @153 @141 @395 +@506 := @411 @1 +@509 := @410 (@506 @363) @417 +@510 := @436 @1 +@520 := (hbind : @408) -> + (hF : @509) -> (hA : @482) -> (hne : @426) -> @429 (fun (ro : @428) => @435 (@510 @440 @412 @17)) +@530 := {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @361} -> {F : @335} -> {o : @337} -> (hB : @502) -> (hfn : @474) -> (hwt : @505) -> @520 +@531 := @497 @2 +@533 := @498 @2 @17 +@535 := (n : @63) -> @533 @139 +@536 := @133 @141 +@537 := @536 @395 +@546 := {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @361} -> {F : @335} -> {o : @337} -> (hB : @535) -> (hfn : @474) -> (hwt : @537) -> @520 +@547 := @531 @73 +@549 := (n : @63) -> @533 @73 +@550 := @471 @73 +@551 := @373 @550 +@552 := @551 @387 +@553 := @506 @73 +@554 := @410 @553 +@555 := @554 @417 +@556 := @479 @73 +@558 := @556 @153 @141 +@560 := @510 (@439 @73) +@568 := (hF : @555) -> (hA : @558) -> (hne : @426) -> @429 (fun (ro : @428) => @435 (@560 @412 @17)) +@577 := {fn : @83} -> + {args : @137} -> + {env : @361} -> + {F : @335} -> {o : @337} -> (hB : @549) -> (hfn : @552) -> (hwt : @537) -> (hbind : @408) -> @568 +@578 := @547 @103 +@580 := @551 (@386 @103) +@581 := @394 @103 +@582 := @536 @581 +@584 := @399 (@400 @103) +@596 := {args : @137} -> + {env : @361} -> + {F : @335} -> + {o : @337} -> + (hB : @549) -> (hfn : @580) -> (hwt : @582) -> (hbind : @398 (@584 @139 @76) @407) -> @568 +@597 := @578 @62 +@599 := @283 (@230 @57) +@601 := @133 @599 @581 +@603 := @58 (@5 @153) +@605 := @603 (@283 @57) +@609 := @398 (@584 @605 @76) @407 +@611 := @58 (@5 @389) +@613 := @58 (@5 @363) +@615 := @611 (@613 @57) +@617 := @556 @615 @141 +@619 := @58 (@5 @420) +@622 := @58 (@5 #12) +@639 := {env : @361} -> + {F : @335} -> + {o : @337} -> + (hB : @549) -> + (hfn : @580) -> + (hwt : @601) -> + (hbind : @609) -> + (hF : @555) -> + (hA : @617) -> (hne : @426) -> @429 (fun (ro : @428) => @435 (@560 (@619 (@622 @57)) @17)) +@640 := @597 @81 +@642 := @230 (@244 @57) +@644 := @133 @642 @581 +@655 := @398 (@584 @599 @76) (@406 (@77 (@71 @229) (@77 (@74 @282) @76))) +@657 := @613 (@603 @57) +@659 := @556 @657 @141 +@661 := @58 (@5 @412) +@677 := {F : @335} -> + {o : @337} -> + (hB : @549) -> + (hfn : @580) -> + (hwt : @644) -> + (hbind : @655) -> + (hF : @555) -> + (hA : @659) -> (hne : @426) -> @429 (fun (ro : @428) => @435 (@560 (@622 (@661 @57)) @17)) +@678 := @640 @82 +@679 := @302 @581 +@690 := @398 (@584 @642 @76) (@406 (@77 (@71 @243) (@77 (@74 @229) @76))) +@692 := @554 (@416 @82) +@694 := @556 @605 @141 +@695 := @431 @82 +@713 := {o : @337} -> + (hB : @549) -> + (hfn : @580) -> + (hwt : @679) -> + (hbind : @690) -> + (hF : @692) -> + (hA : @694) -> + (hne : @426) -> @429 (fun (ro : @428) => @430 (@695 @153 @17) (@560 (@661 (@611 @57)) @17)) +@714 := @678 @324 +@715 := @309 @581 +@726 := @398 (@584 @301 @76) (@406 (@77 (@71 @226) (@77 (@74 @243) @76))) +@727 := @556 @599 +@729 := @322 @147 @139 +@730 := @727 @729 +@732 := @322 @153 @147 +@751 := (hB : @549) -> + (hfn : @580) -> + (hwt : @715) -> + (hbind : @726) -> + (hF : @692) -> + (hA : @730) -> + (hne : @338 @732 @343) -> + @429 (fun (ro : @428) => @430 (@695 (@322 @389 @363) @17) (@560 @615 @17)) +@752 := @714 @107 +@753 := @316 @581 +@764 := @398 (@584 @308 @76) (@406 (@77 (@71 @240) (@77 (@74 @226) @76))) +@765 := @556 @642 +@767 := @322 @139 @141 +@786 := (hfn : @580) -> + (hwt : @753) -> + (hbind : @764) -> + (hF : @692) -> + (hA : @765 @767) -> + (hne : @338 @729 @343) -> + @429 (fun (ro : @428) => @430 (@695 (@322 @363 @153) @17) (@560 @657 @17)) +@787 := Eq.refl.{1} +@790 := @752 (@787 @372 @550) +@791 := @320 @581 +@802 := @398 (@584 @315 @76) (@406 (@77 (@71 @6) (@77 (@74 @240) @76))) +@803 := @556 @301 +@805 := @322 @141 @143 +@821 := (hwt : @791) -> + (hbind : @802) -> + (hF : @692) -> + (hA : @803 @805) -> + (hne : @338 @767 @343) -> @429 (fun (ro : @428) => @430 (@695 @732 @17) (@560 @605 @17)) +@822 := @790 @319 +@824 := @584 @62 @76 +@827 := @398 @824 (@406 @81) +@828 := @556 @308 +@830 := @322 @143 @12 +@845 := (hbind : @827) -> + (hF : @692) -> + (hA : @828 @830) -> + (hne : @338 @805 @343) -> @429 (fun (ro : @428) => @430 (@695 @729 @17) (@560 @599 @17)) +@848 := @822 (@787 @397 @824) +@849 := @556 @315 +@851 := @322 @12 @4 +@865 := (hF : @692) -> + (hA : @849 @851) -> + (hne : @338 @830 @343) -> @429 (fun (ro : @428) => @430 (@695 @767 @17) (@560 @642 @17)) +@868 := @848 (@787 @409 @553) +@882 := (hA : @556 @62 @324) -> + (hne : @338 @851 @343) -> @429 (fun (ro : @428) => @430 (@695 @805 @17) (@560 @301 @17)) +@883 := @868 @334 +@894 := (hne : @338 @324 @343) -> @429 (fun (ro : @428) => @430 (@695 @830 @17) (@560 @308 @17)) +@895 := @883 @356 +@901 := @430 (@695 @851 @17) (@560 @315 @17) +@903 := @429 (fun (ro : @428) => @901) +@905 := @429 (fun (__e_ro : @428) => @901) +@910 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@911 := (__e_hrep : @910) -> @905 +@912 := fun (__e_hrep : @910) => @895 +@913 := (b : @3) -> @911 +@914 := fun (b : @3) => @912 +@915 := (a : @3) -> @913 +@916 := fun (a : @3) => @914 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustCore.lean deleted file mode 100644 index 2cb1e5f22..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustCore.lean +++ /dev/null @@ -1,21 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore - -theorem __wt_0 : ∀ (__v : (Coverage.Types.Shape)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.__enc_0 __v) (.adt 0) - | Coverage.Types.Shape.circle __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - | Coverage.Types.Shape.rect __x0 __x1 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x1) _root_.LexLeanPreservation.Rust.wtl_nil)) - | Coverage.Types.Shape.empty => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (w : Nat) (h : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat w), (_root_.LexLeanTarget.TargetSyntax.Value.nat h)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.denote w h) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat w), (_root_.LexLeanTarget.TargetSyntax.Value.nat h)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat w) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat h) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.root w h) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustCore.lex.tex new file mode 100644 index 000000000..c5413a799 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustCore.lex.tex @@ -0,0 +1,578 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore.__wt_0 : @16 := @482 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore.root : @1157 := @1158 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.flags +@3 := Coverage.Types.Shape +@4 := #0 +@6 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.__enc_0 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := (__v : @3) -> @15 +@17 := fun (__v : @3) => @15 +@18 := LexLeanTarget.TargetSyntax.Value.nat +@19 := @18 @4 +@20 := LexLeanTarget.TargetSyntax.Ty.nat +@21 := LexLeanTarget.TargetSyntax.Program +@22 := LexLeanPreservation.Rust.RCrate +@23 := LexLeanPreservation.Rust.Flags +@24 := Nat +@25 := #3 +@26 := @7 @25 +@27 := #2 +@28 := @26 @27 +@29 := #1 +@36 := {p : @21} -> {c : @22} -> {A : @23} -> (n : @24) -> @28 @29 @19 @20 +@38 := LexLeanPreservation.Rust.wt_nat @0 +@45 := {c : @22} -> {A : @23} -> (n : @24) -> @11 @27 @29 @19 @20 +@46 := @38 @1 +@51 := {A : @23} -> (n : @24) -> @12 @29 @19 @20 +@52 := @46 @2 +@54 := @13 @19 @20 +@55 := (n : @24) -> @54 +@56 := @52 @4 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := LexLeanTarget.TargetSyntax.Ty +@59 := List.nil.{0} +@60 := List.cons.{0} +@61 := @59 @57 +@62 := @60 @57 +@64 := @62 @19 @61 +@65 := @59 @58 +@66 := @60 @58 +@67 := @66 @20 +@68 := @67 @65 +@69 := LexLeanPreservation.Rust.WTL +@77 := {p : @21} -> {c : @22} -> {A : @23} -> @69 @27 @29 @4 @61 @65 +@79 := LexLeanPreservation.Rust.wtl_nil @0 +@80 := @69 @0 +@86 := {c : @22} -> {A : @23} -> @80 @29 @4 @61 @65 +@87 := @79 @1 +@88 := @80 @1 +@92 := {A : @23} -> @88 @4 @61 @65 +@93 := @87 @2 +@94 := @88 @2 +@95 := @94 @61 +@96 := @95 @65 +@97 := List.{0} +@98 := @97 @57 +@99 := @97 @58 +@100 := #6 +@101 := @7 @100 +@102 := #5 +@103 := @101 @102 +@104 := #4 +@107 := @103 @104 @25 @27 +@108 := #7 +@113 := @69 @108 @100 @102 @27 @29 +@114 := #8 +@117 := @69 @114 @108 @100 +@119 := @62 @102 @25 +@120 := @117 @119 +@122 := @66 @104 @27 +@132 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {v : @57} -> {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @107) -> (hs : @113) -> @120 @122 +@134 := LexLeanPreservation.Rust.wtl_cons @0 +@138 := @11 @102 @104 @25 @27 +@142 := @80 @100 @102 @27 @29 +@154 := {c : @22} -> + {A : @23} -> + {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @138) -> (hs : @142) -> @80 @108 @100 @119 @122 +@155 := @134 @1 +@158 := @12 @104 @25 @27 +@161 := @88 @102 @27 @29 +@171 := {A : @23} -> + {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @158) -> (hs : @161) -> @88 @100 @119 @122 +@172 := @155 @2 +@174 := @13 @25 @27 +@176 := @94 @27 @29 +@184 := {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @174) -> (hs : @176) -> @94 @119 @122 +@185 := @172 @19 +@186 := @18 @25 +@187 := @13 @186 +@188 := @187 @27 +@189 := @18 @102 +@190 := @62 @189 +@192 := @94 (@190 @25) +@198 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @188) -> (hs : @176) -> @192 @122 +@199 := @185 @20 +@200 := @18 @27 +@202 := @13 @200 @20 +@203 := @18 @104 +@204 := @62 @203 +@206 := @94 (@204 @25) +@207 := @67 @27 +@212 := {vs : @98} -> {ts : @99} -> (h : @202) -> (hs : @176) -> @206 @207 +@213 := @199 @61 +@214 := @18 @29 +@216 := @13 @214 @20 +@217 := @95 @29 +@218 := @62 @186 +@219 := @218 @61 +@220 := @94 @219 +@224 := {ts : @99} -> (h : @216) -> (hs : @217) -> @220 @207 +@225 := @213 @65 +@226 := @62 @200 +@227 := @226 @61 +@228 := @94 @227 +@229 := @228 @68 +@231 := (h : @54) -> (hs : @96) -> @229 +@232 := @225 @56 +@233 := @62 @214 +@234 := @233 @61 +@236 := @94 @234 @68 +@237 := (hs : @96) -> @236 +@238 := @232 @93 +@240 := @94 @64 @68 +@241 := Eq.{1} +@242 := Option.{0} +@243 := @242 @99 +@244 := @241 @243 +@245 := LexLeanPreservation.Rust.adtFields +@249 := @244 (@245 @100 @25 @27) +@250 := Option.some.{0} +@251 := @250 @99 +@252 := @251 @4 +@253 := @249 @252 +@256 := @7 @114 @108 @100 +@257 := LexLeanTarget.TargetSyntax.Value.adt +@259 := @257 @104 @25 +@260 := @256 @259 +@261 := @8 @102 +@271 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {i : @24} -> {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @253) -> (hf : @113) -> @260 @261 +@273 := LexLeanPreservation.Rust.wt_adt @0 +@274 := @245 @0 +@278 := @244 (@274 @25 @27) @252 +@290 := {c : @22} -> + {A : @23} -> + {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @142) -> @11 @108 @100 @259 @261 +@291 := @273 @1 +@301 := {A : @23} -> + {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @161) -> @12 @100 @259 @261 +@302 := @291 @2 +@303 := @13 @259 +@310 := {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @176) -> @303 @261 +@311 := @302 @9 +@312 := @274 @9 +@321 := {k : @24} -> + {fs : @98} -> {tys : @99} -> (h : @244 (@312 @27) @252) -> (hf : @176) -> @303 @10 +@322 := @311 @9 +@323 := @312 @9 +@324 := @244 @323 +@325 := @324 @252 +@326 := @257 @9 +@333 := {fs : @98} -> {tys : @99} -> (h : @325) -> (hf : @176) -> @13 (@326 @25) @10 +@334 := @322 @64 +@335 := @228 @29 +@341 := {tys : @99} -> (h : @325) -> (hf : @335) -> @13 (@326 @219) @10 +@342 := @334 @68 +@349 := (h : @324 (@251 @68)) -> (hf : @236) -> @13 (@326 @227) @10 +@350 := Eq.refl.{1} +@351 := @350 @243 +@353 := @342 (@351 @323) +@357 := (hf : @240) -> @13 (@326 @234) @10 +@358 := @353 @238 +@361 := @13 (@326 @64) @10 +@362 := fun (__x0 : @24) => @358 +@363 := @52 @29 +@364 := @233 @64 +@365 := @67 @68 +@366 := @172 @214 +@367 := @13 @203 +@368 := @367 @27 +@369 := @18 @100 +@370 := @62 @369 +@372 := @94 (@370 @25) +@378 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @368) -> (hs : @176) -> @372 @122 +@379 := @366 @20 +@380 := @187 @20 +@385 := {vs : @98} -> {ts : @99} -> (h : @380) -> (hs : @176) -> @192 @207 +@386 := @379 @64 +@387 := @204 @219 +@388 := @94 @387 +@392 := {ts : @99} -> (h : @202) -> (hs : @335) -> @388 @207 +@393 := @386 @68 +@394 := @218 @227 +@395 := @94 @394 +@398 := (h : @216) -> (hs : @236) -> @395 @365 +@399 := @393 @363 +@400 := @226 @234 +@401 := @94 @400 +@402 := @401 @365 +@403 := (hs : @240) -> @402 +@404 := @399 @238 +@406 := @94 @364 @365 +@407 := 1 +@408 := @311 @407 +@409 := @312 @407 +@410 := @244 @409 +@411 := @410 @252 +@412 := @257 @407 +@419 := {fs : @98} -> {tys : @99} -> (h : @411) -> (hf : @176) -> @13 (@412 @25) @10 +@420 := @408 @364 +@427 := {tys : @99} -> (h : @411) -> (hf : @395 @29) -> @13 (@412 @387) @10 +@428 := @420 @365 +@435 := (h : @410 (@251 @365)) -> (hf : @402) -> @13 (@412 @394) @10 +@437 := @428 (@351 @409) +@441 := (hf : @406) -> @13 (@412 @400) @10 +@442 := @437 @404 +@445 := @13 (@412 @364) @10 +@447 := fun (__x0 : @24) => fun (__x1 : @24) => @442 +@448 := 2 +@449 := @311 @448 +@450 := @312 @448 +@451 := @244 @450 +@452 := @451 @252 +@453 := @257 @448 +@460 := {fs : @98} -> {tys : @99} -> (h : @452) -> (hf : @176) -> @13 (@453 @25) @10 +@461 := @449 @61 +@464 := @13 (@453 @61) @10 +@467 := {tys : @99} -> (h : @452) -> (hf : @217) -> @464 +@468 := @461 @65 +@472 := (h : @451 (@251 @65)) -> (hf : @96) -> @464 +@475 := @468 (@351 @450) @93 +@482 := fun (__v : @3) => Coverage.Types.Shape.casesOn.{0} @17 @4 @362 @447 @475 +@483 := @52 @27 +@486 := Prod.{0, 0} @24 @57 +@489 := Prod.mk.{0, 0} @24 @57 +@490 := @489 @407 +@491 := @490 @214 +@492 := @489 @9 +@493 := @492 @200 +@494 := @59 @486 +@495 := @60 @486 +@497 := @495 @493 @494 +@499 := @495 @491 @497 +@500 := Bool.true +@501 := LexLeanTarget.TargetSyntax.Function +@502 := LexLeanTarget.TargetSyntax.Program.functions +@503 := @502 @0 +@504 := @59 @24 +@505 := LexLeanTarget.TargetSyntax.Ty.unit +@506 := LexLeanTarget.TargetSyntax.Value.unit +@509 := LexLeanTarget.TargetSyntax.Expr.value @505 @506 +@514 := LexLeanTarget.TargetSyntax.Function.mk @504 @65 @505 @509 +@519 := List.getD.{0} @501 @503 @9 @514 +@523 := fun (__e_n : @24) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.root @4 @9 +@524 := @379 @61 +@525 := @204 @61 +@530 := {ts : @99} -> (h : @202) -> (hs : @217) -> @94 @525 @207 +@531 := @524 @65 +@534 := (h : @216) -> (hs : @96) -> @220 @68 +@536 := @531 @363 @93 +@537 := @172 @200 +@539 := @13 @189 @27 +@540 := @18 @108 +@541 := @62 @540 +@549 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @539) -> (hs : @176) -> @94 (@541 @25) @122 +@550 := @537 @20 +@556 := {vs : @98} -> {ts : @99} -> (h : @367 @20) -> (hs : @176) -> @372 @207 +@557 := @550 @234 +@558 := @220 @29 +@559 := @190 @525 +@560 := @94 @559 +@564 := {ts : @99} -> (h : @380) -> (hs : @558) -> @560 @207 +@565 := @557 @68 +@568 := (h : @202) -> (hs : @229) -> @388 @365 +@570 := @565 @483 @536 +@571 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.denote +@573 := @571 @27 @29 +@574 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.__fits_0 +@576 := @574 @27 @29 +@580 := @18 (Coverage.Main.shapes @27 @29) +@583 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.root @27 @29 +@584 := Bool +@585 := Ne.{1} +@586 := LexLeanPreservation.Obs +@587 := @585 @586 +@588 := LexLeanPreservation.Rel +@591 := @587 (@588 @29 @4) +@592 := LexLeanPreservation.Obs.stuck +@595 := (f : @584) -> (v : @57) -> @591 @592 +@597 := LexLeanPreservation.Rust.rel_ne_stuck @576 +@604 := (v : @57) -> @587 (@588 (@574 @25 @27) @4) @592 +@605 := @597 @580 +@609 := @587 (@588 @576 @580) @592 +@610 := @97 @486 +@611 := LexLeanPreservation.Rust.FunSem +@612 := #9 +@618 := (n : @24) -> @611 @612 @114 @108 @4 @100 +@619 := @242 @501 +@620 := @241 @619 +@627 := LexLeanRuntime.index (@97 @501) @501 (LexLeanRuntime.instIndexableList @501) +@631 := @620 (@627 (@502 @612) @100) +@632 := @250 @501 +@633 := @632 @102 +@634 := @631 @633 +@635 := #10 +@639 := @69 @635 @612 @114 @102 +@640 := LexLeanTarget.TargetSyntax.Function.types +@641 := @640 @100 +@642 := @639 @641 +@643 := @242 @610 +@644 := @241 @643 +@645 := LexLeanTarget.TargetSemantics.bindAll +@646 := LexLeanTarget.TargetSyntax.Function.parameters +@651 := @644 (@645 (@646 @108) @100 @494) +@652 := @250 @610 +@653 := @652 @102 +@654 := @651 @653 +@655 := @242 @584 +@656 := @241 @655 +@657 := LexLeanPreservation.Rust.fnFallible +@658 := #11 +@661 := @656 (@657 @658 @612) +@662 := @250 @584 +@663 := @662 @102 +@664 := @661 @663 +@665 := LexLeanPreservation.RunConv +@666 := #13 +@670 := @665 @666 @635 @114 @102 +@672 := @587 @100 @592 +@673 := Exists.{1} +@674 := LexLeanPreservation.Rust.ROut +@675 := @673 @674 +@676 := And +@677 := LexLeanPreservation.Rust.RealizesFn +@681 := @676 (@677 @612 @114 @4) +@682 := LexLeanPreservation.Rust.RCI +@684 := @682 #15 +@685 := LexLeanPreservation.Rust.fnIdent +@686 := @685 @666 +@693 := (hne : @672) -> @675 (fun (ro : @674) => @681 (@684 @686 @658 @4)) +@708 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {f : @24} -> + {fn : @501} -> + {args : @98} -> + {env : @610} -> + {F : @584} -> + {o : @586} -> + (hB : @618) -> + (hfn : @634) -> (hwt : @642) -> (hbind : @654) -> (hF : @664) -> (hA : @670) -> @693 +@710 := LexLeanPreservation.Rust.compose @0 +@711 := @611 @0 +@716 := (n : @24) -> @711 @114 @108 @4 @100 +@717 := @627 @503 +@720 := @620 (@717 @100) @633 +@724 := @80 @612 @114 @102 @641 +@725 := @665 @0 +@728 := @725 @635 @114 @102 +@742 := {c : @22} -> + {A : @23} -> + {f : @24} -> + {fn : @501} -> + {args : @98} -> + {env : @610} -> + {F : @584} -> + {o : @586} -> + (hB : @716) -> + (hfn : @720) -> (hwt : @724) -> (hbind : @654) -> (hF : @664) -> (hA : @728) -> @693 +@743 := @710 @1 +@744 := @711 @1 +@748 := (n : @24) -> @744 @108 @4 @100 +@751 := @88 @114 @102 @641 +@752 := @657 @1 +@755 := @656 (@752 @612) @663 +@756 := @682 @1 +@766 := (hbind : @654) -> + (hF : @755) -> (hA : @728) -> (hne : @672) -> @675 (fun (ro : @674) => @681 (@756 @686 @658 @4)) +@776 := {A : @23} -> + {f : @24} -> + {fn : @501} -> + {args : @98} -> + {env : @610} -> {F : @584} -> {o : @586} -> (hB : @748) -> (hfn : @720) -> (hwt : @751) -> @766 +@777 := @743 @2 +@779 := @744 @2 @4 +@781 := (n : @24) -> @779 @100 +@782 := @94 @102 +@783 := @782 @641 +@792 := {f : @24} -> + {fn : @501} -> + {args : @98} -> + {env : @610} -> {F : @584} -> {o : @586} -> (hB : @781) -> (hfn : @720) -> (hwt : @783) -> @766 +@793 := @777 @9 +@795 := (n : @24) -> @779 @9 +@796 := @717 @9 +@797 := @620 @796 +@798 := @797 @633 +@799 := @752 @9 +@800 := @656 @799 +@801 := @800 @663 +@802 := @725 @9 +@804 := @802 @114 @102 +@806 := @756 (@685 @9) +@814 := (hF : @801) -> (hA : @804) -> (hne : @672) -> @675 (fun (ro : @674) => @681 (@806 @658 @4)) +@823 := {fn : @501} -> + {args : @98} -> + {env : @610} -> + {F : @584} -> {o : @586} -> (hB : @795) -> (hfn : @798) -> (hwt : @783) -> (hbind : @654) -> @814 +@824 := @793 @519 +@826 := @797 (@632 @519) +@827 := @640 @519 +@828 := @782 @827 +@830 := @645 (@646 @519) +@842 := {args : @98} -> + {env : @610} -> + {F : @584} -> + {o : @586} -> + (hB : @795) -> (hfn : @826) -> (hwt : @828) -> (hbind : @644 (@830 @100 @494) @653) -> @814 +@843 := @824 @400 +@845 := @541 (@370 @61) +@847 := @94 @845 @827 +@849 := @62 (@18 @114) +@851 := @849 (@541 @61) +@855 := @644 (@830 @851 @494) @653 +@857 := @62 (@18 @635) +@859 := @62 (@18 @612) +@861 := @857 (@859 @61) +@863 := @802 @861 @102 +@865 := @62 (@18 @666) +@868 := @62 (@18 #12) +@885 := {env : @610} -> + {F : @584} -> + {o : @586} -> + (hB : @795) -> + (hfn : @826) -> + (hwt : @847) -> + (hbind : @855) -> + (hF : @801) -> + (hA : @863) -> (hne : @672) -> @675 (fun (ro : @674) => @681 (@806 (@865 (@868 @61)) @4)) +@886 := @843 @499 +@888 := @370 (@190 @61) +@890 := @94 @888 @827 +@901 := @644 (@830 @845 @494) (@652 (@495 (@490 @369) (@495 (@492 @540) @494))) +@903 := @859 (@849 @61) +@905 := @802 @903 @102 +@907 := @62 (@18 @658) +@923 := {F : @584} -> + {o : @586} -> + (hB : @795) -> + (hfn : @826) -> + (hwt : @890) -> + (hbind : @901) -> + (hF : @801) -> + (hA : @905) -> (hne : @672) -> @675 (fun (ro : @674) => @681 (@806 (@868 (@907 @61)) @4)) +@924 := @886 @500 +@925 := @560 @827 +@936 := @644 (@830 @888 @494) (@652 (@495 (@490 @189) (@495 (@492 @369) @494))) +@938 := @800 (@662 @500) +@940 := @802 @851 @102 +@941 := @677 @500 +@959 := {o : @586} -> + (hB : @795) -> + (hfn : @826) -> + (hwt : @925) -> + (hbind : @936) -> + (hF : @938) -> + (hA : @940) -> + (hne : @672) -> @675 (fun (ro : @674) => @676 (@941 @114 @4) (@806 (@907 (@857 @61)) @4)) +@960 := @924 @573 +@961 := @388 @827 +@972 := @644 (@830 @559 @494) (@652 (@495 (@490 @203) (@495 (@492 @189) @494))) +@973 := @802 @845 +@975 := @571 @108 @100 +@976 := @973 @975 +@978 := @571 @114 @108 +@997 := (hB : @795) -> + (hfn : @826) -> + (hwt : @961) -> + (hbind : @972) -> + (hF : @938) -> + (hA : @976) -> + (hne : @587 @978 @592) -> @675 (fun (ro : @674) => @676 (@941 (@571 @635 @612) @4) (@806 @861 @4)) +@998 := @960 @523 +@999 := @395 @827 +@1010 := @644 (@830 @387 @494) (@652 (@495 (@490 @186) (@495 (@492 @203) @494))) +@1011 := @802 @888 +@1013 := @571 @100 @102 +@1032 := (hfn : @826) -> + (hwt : @999) -> + (hbind : @1010) -> + (hF : @938) -> + (hA : @1011 @1013) -> + (hne : @587 @975 @592) -> @675 (fun (ro : @674) => @676 (@941 (@571 @612 @114) @4) (@806 @903 @4)) +@1035 := @998 (@350 @619 @796) +@1036 := @401 @827 +@1047 := @644 (@830 @394 @494) (@652 (@495 (@490 @200) (@495 (@492 @186) @494))) +@1048 := @802 @559 +@1050 := @571 @102 @104 +@1066 := (hwt : @1036) -> + (hbind : @1047) -> + (hF : @938) -> + (hA : @1048 @1050) -> + (hne : @587 @1013 @592) -> @675 (fun (ro : @674) => @676 (@941 @978 @4) (@806 @851 @4)) +@1067 := @1035 @570 +@1069 := @830 @400 @494 +@1072 := @644 @1069 (@652 @499) +@1073 := @802 @387 +@1075 := @571 @104 @25 +@1090 := (hbind : @1072) -> + (hF : @938) -> + (hA : @1073 @1075) -> + (hne : @587 @1050 @592) -> @675 (fun (ro : @674) => @676 (@941 @975 @4) (@806 @845 @4)) +@1093 := @1067 (@350 @643 @1069) +@1094 := @802 @394 +@1096 := @571 @25 @27 +@1110 := (hF : @938) -> + (hA : @1094 @1096) -> + (hne : @587 @1075 @592) -> @675 (fun (ro : @674) => @676 (@941 @1013 @4) (@806 @888 @4)) +@1113 := @1093 (@350 @655 @799) +@1127 := (hA : @802 @400 @573) -> + (hne : @587 @1096 @592) -> @675 (fun (ro : @674) => @676 (@941 @1050 @4) (@806 @559 @4)) +@1128 := @1113 @583 +@1139 := (hne : @587 @573 @592) -> @675 (fun (ro : @674) => @676 (@941 @1075 @4) (@806 @387 @4)) +@1140 := @1128 @605 +@1146 := @676 (@941 @1096 @4) (@806 @394 @4) +@1148 := @675 (fun (ro : @674) => @1146) +@1150 := @675 (fun (__e_ro : @674) => @1146) +@1152 := LexLeanPreservation.Rust.RepresentableL @364 +@1153 := (__e_hrep : @1152) -> @1150 +@1154 := fun (__e_hrep : @1152) => @1140 +@1155 := (h : @24) -> @1153 +@1156 := fun (h : @24) => @1154 +@1157 := (w : @24) -> @1155 +@1158 := fun (w : @24) => @1156 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustStd.lean deleted file mode 100644 index df7eacadb..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustStd.lean +++ /dev/null @@ -1,21 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Coverage.Types.Shape)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.__enc_0 __v) (.adt 0) - | Coverage.Types.Shape.circle __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - | Coverage.Types.Shape.rect __x0 __x1 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x1) _root_.LexLeanPreservation.Rust.wtl_nil)) - | Coverage.Types.Shape.empty => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (w : Nat) (h : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat w), (_root_.LexLeanTarget.TargetSyntax.Value.nat h)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.denote w h) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat w), (_root_.LexLeanTarget.TargetSyntax.Value.nat h)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat w) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat h) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.root w h) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustStd.lex.tex new file mode 100644 index 000000000..be3941ee5 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustStd.lex.tex @@ -0,0 +1,578 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd.__wt_0 : @16 := @482 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd.root : @1157 := @1158 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.flags +@3 := Coverage.Types.Shape +@4 := #0 +@6 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.__enc_0 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := (__v : @3) -> @15 +@17 := fun (__v : @3) => @15 +@18 := LexLeanTarget.TargetSyntax.Value.nat +@19 := @18 @4 +@20 := LexLeanTarget.TargetSyntax.Ty.nat +@21 := LexLeanTarget.TargetSyntax.Program +@22 := LexLeanPreservation.Rust.RCrate +@23 := LexLeanPreservation.Rust.Flags +@24 := Nat +@25 := #3 +@26 := @7 @25 +@27 := #2 +@28 := @26 @27 +@29 := #1 +@36 := {p : @21} -> {c : @22} -> {A : @23} -> (n : @24) -> @28 @29 @19 @20 +@38 := LexLeanPreservation.Rust.wt_nat @0 +@45 := {c : @22} -> {A : @23} -> (n : @24) -> @11 @27 @29 @19 @20 +@46 := @38 @1 +@51 := {A : @23} -> (n : @24) -> @12 @29 @19 @20 +@52 := @46 @2 +@54 := @13 @19 @20 +@55 := (n : @24) -> @54 +@56 := @52 @4 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := LexLeanTarget.TargetSyntax.Ty +@59 := List.nil.{0} +@60 := List.cons.{0} +@61 := @59 @57 +@62 := @60 @57 +@64 := @62 @19 @61 +@65 := @59 @58 +@66 := @60 @58 +@67 := @66 @20 +@68 := @67 @65 +@69 := LexLeanPreservation.Rust.WTL +@77 := {p : @21} -> {c : @22} -> {A : @23} -> @69 @27 @29 @4 @61 @65 +@79 := LexLeanPreservation.Rust.wtl_nil @0 +@80 := @69 @0 +@86 := {c : @22} -> {A : @23} -> @80 @29 @4 @61 @65 +@87 := @79 @1 +@88 := @80 @1 +@92 := {A : @23} -> @88 @4 @61 @65 +@93 := @87 @2 +@94 := @88 @2 +@95 := @94 @61 +@96 := @95 @65 +@97 := List.{0} +@98 := @97 @57 +@99 := @97 @58 +@100 := #6 +@101 := @7 @100 +@102 := #5 +@103 := @101 @102 +@104 := #4 +@107 := @103 @104 @25 @27 +@108 := #7 +@113 := @69 @108 @100 @102 @27 @29 +@114 := #8 +@117 := @69 @114 @108 @100 +@119 := @62 @102 @25 +@120 := @117 @119 +@122 := @66 @104 @27 +@132 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {v : @57} -> {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @107) -> (hs : @113) -> @120 @122 +@134 := LexLeanPreservation.Rust.wtl_cons @0 +@138 := @11 @102 @104 @25 @27 +@142 := @80 @100 @102 @27 @29 +@154 := {c : @22} -> + {A : @23} -> + {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @138) -> (hs : @142) -> @80 @108 @100 @119 @122 +@155 := @134 @1 +@158 := @12 @104 @25 @27 +@161 := @88 @102 @27 @29 +@171 := {A : @23} -> + {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @158) -> (hs : @161) -> @88 @100 @119 @122 +@172 := @155 @2 +@174 := @13 @25 @27 +@176 := @94 @27 @29 +@184 := {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @174) -> (hs : @176) -> @94 @119 @122 +@185 := @172 @19 +@186 := @18 @25 +@187 := @13 @186 +@188 := @187 @27 +@189 := @18 @102 +@190 := @62 @189 +@192 := @94 (@190 @25) +@198 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @188) -> (hs : @176) -> @192 @122 +@199 := @185 @20 +@200 := @18 @27 +@202 := @13 @200 @20 +@203 := @18 @104 +@204 := @62 @203 +@206 := @94 (@204 @25) +@207 := @67 @27 +@212 := {vs : @98} -> {ts : @99} -> (h : @202) -> (hs : @176) -> @206 @207 +@213 := @199 @61 +@214 := @18 @29 +@216 := @13 @214 @20 +@217 := @95 @29 +@218 := @62 @186 +@219 := @218 @61 +@220 := @94 @219 +@224 := {ts : @99} -> (h : @216) -> (hs : @217) -> @220 @207 +@225 := @213 @65 +@226 := @62 @200 +@227 := @226 @61 +@228 := @94 @227 +@229 := @228 @68 +@231 := (h : @54) -> (hs : @96) -> @229 +@232 := @225 @56 +@233 := @62 @214 +@234 := @233 @61 +@236 := @94 @234 @68 +@237 := (hs : @96) -> @236 +@238 := @232 @93 +@240 := @94 @64 @68 +@241 := Eq.{1} +@242 := Option.{0} +@243 := @242 @99 +@244 := @241 @243 +@245 := LexLeanPreservation.Rust.adtFields +@249 := @244 (@245 @100 @25 @27) +@250 := Option.some.{0} +@251 := @250 @99 +@252 := @251 @4 +@253 := @249 @252 +@256 := @7 @114 @108 @100 +@257 := LexLeanTarget.TargetSyntax.Value.adt +@259 := @257 @104 @25 +@260 := @256 @259 +@261 := @8 @102 +@271 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {i : @24} -> {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @253) -> (hf : @113) -> @260 @261 +@273 := LexLeanPreservation.Rust.wt_adt @0 +@274 := @245 @0 +@278 := @244 (@274 @25 @27) @252 +@290 := {c : @22} -> + {A : @23} -> + {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @142) -> @11 @108 @100 @259 @261 +@291 := @273 @1 +@301 := {A : @23} -> + {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @161) -> @12 @100 @259 @261 +@302 := @291 @2 +@303 := @13 @259 +@310 := {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @176) -> @303 @261 +@311 := @302 @9 +@312 := @274 @9 +@321 := {k : @24} -> + {fs : @98} -> {tys : @99} -> (h : @244 (@312 @27) @252) -> (hf : @176) -> @303 @10 +@322 := @311 @9 +@323 := @312 @9 +@324 := @244 @323 +@325 := @324 @252 +@326 := @257 @9 +@333 := {fs : @98} -> {tys : @99} -> (h : @325) -> (hf : @176) -> @13 (@326 @25) @10 +@334 := @322 @64 +@335 := @228 @29 +@341 := {tys : @99} -> (h : @325) -> (hf : @335) -> @13 (@326 @219) @10 +@342 := @334 @68 +@349 := (h : @324 (@251 @68)) -> (hf : @236) -> @13 (@326 @227) @10 +@350 := Eq.refl.{1} +@351 := @350 @243 +@353 := @342 (@351 @323) +@357 := (hf : @240) -> @13 (@326 @234) @10 +@358 := @353 @238 +@361 := @13 (@326 @64) @10 +@362 := fun (__x0 : @24) => @358 +@363 := @52 @29 +@364 := @233 @64 +@365 := @67 @68 +@366 := @172 @214 +@367 := @13 @203 +@368 := @367 @27 +@369 := @18 @100 +@370 := @62 @369 +@372 := @94 (@370 @25) +@378 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @368) -> (hs : @176) -> @372 @122 +@379 := @366 @20 +@380 := @187 @20 +@385 := {vs : @98} -> {ts : @99} -> (h : @380) -> (hs : @176) -> @192 @207 +@386 := @379 @64 +@387 := @204 @219 +@388 := @94 @387 +@392 := {ts : @99} -> (h : @202) -> (hs : @335) -> @388 @207 +@393 := @386 @68 +@394 := @218 @227 +@395 := @94 @394 +@398 := (h : @216) -> (hs : @236) -> @395 @365 +@399 := @393 @363 +@400 := @226 @234 +@401 := @94 @400 +@402 := @401 @365 +@403 := (hs : @240) -> @402 +@404 := @399 @238 +@406 := @94 @364 @365 +@407 := 1 +@408 := @311 @407 +@409 := @312 @407 +@410 := @244 @409 +@411 := @410 @252 +@412 := @257 @407 +@419 := {fs : @98} -> {tys : @99} -> (h : @411) -> (hf : @176) -> @13 (@412 @25) @10 +@420 := @408 @364 +@427 := {tys : @99} -> (h : @411) -> (hf : @395 @29) -> @13 (@412 @387) @10 +@428 := @420 @365 +@435 := (h : @410 (@251 @365)) -> (hf : @402) -> @13 (@412 @394) @10 +@437 := @428 (@351 @409) +@441 := (hf : @406) -> @13 (@412 @400) @10 +@442 := @437 @404 +@445 := @13 (@412 @364) @10 +@447 := fun (__x0 : @24) => fun (__x1 : @24) => @442 +@448 := 2 +@449 := @311 @448 +@450 := @312 @448 +@451 := @244 @450 +@452 := @451 @252 +@453 := @257 @448 +@460 := {fs : @98} -> {tys : @99} -> (h : @452) -> (hf : @176) -> @13 (@453 @25) @10 +@461 := @449 @61 +@464 := @13 (@453 @61) @10 +@467 := {tys : @99} -> (h : @452) -> (hf : @217) -> @464 +@468 := @461 @65 +@472 := (h : @451 (@251 @65)) -> (hf : @96) -> @464 +@475 := @468 (@351 @450) @93 +@482 := fun (__v : @3) => Coverage.Types.Shape.casesOn.{0} @17 @4 @362 @447 @475 +@483 := @52 @27 +@486 := Prod.{0, 0} @24 @57 +@489 := Prod.mk.{0, 0} @24 @57 +@490 := @489 @407 +@491 := @490 @214 +@492 := @489 @9 +@493 := @492 @200 +@494 := @59 @486 +@495 := @60 @486 +@497 := @495 @493 @494 +@499 := @495 @491 @497 +@500 := Bool.true +@501 := LexLeanTarget.TargetSyntax.Function +@502 := LexLeanTarget.TargetSyntax.Program.functions +@503 := @502 @0 +@504 := @59 @24 +@505 := LexLeanTarget.TargetSyntax.Ty.unit +@506 := LexLeanTarget.TargetSyntax.Value.unit +@509 := LexLeanTarget.TargetSyntax.Expr.value @505 @506 +@514 := LexLeanTarget.TargetSyntax.Function.mk @504 @65 @505 @509 +@519 := List.getD.{0} @501 @503 @9 @514 +@523 := fun (__e_n : @24) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.root @4 @9 +@524 := @379 @61 +@525 := @204 @61 +@530 := {ts : @99} -> (h : @202) -> (hs : @217) -> @94 @525 @207 +@531 := @524 @65 +@534 := (h : @216) -> (hs : @96) -> @220 @68 +@536 := @531 @363 @93 +@537 := @172 @200 +@539 := @13 @189 @27 +@540 := @18 @108 +@541 := @62 @540 +@549 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @539) -> (hs : @176) -> @94 (@541 @25) @122 +@550 := @537 @20 +@556 := {vs : @98} -> {ts : @99} -> (h : @367 @20) -> (hs : @176) -> @372 @207 +@557 := @550 @234 +@558 := @220 @29 +@559 := @190 @525 +@560 := @94 @559 +@564 := {ts : @99} -> (h : @380) -> (hs : @558) -> @560 @207 +@565 := @557 @68 +@568 := (h : @202) -> (hs : @229) -> @388 @365 +@570 := @565 @483 @536 +@571 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.denote +@573 := @571 @27 @29 +@574 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.__fits_0 +@576 := @574 @27 @29 +@580 := @18 (Coverage.Main.shapes @27 @29) +@583 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.root @27 @29 +@584 := Bool +@585 := Ne.{1} +@586 := LexLeanPreservation.Obs +@587 := @585 @586 +@588 := LexLeanPreservation.Rel +@591 := @587 (@588 @29 @4) +@592 := LexLeanPreservation.Obs.stuck +@595 := (f : @584) -> (v : @57) -> @591 @592 +@597 := LexLeanPreservation.Rust.rel_ne_stuck @576 +@604 := (v : @57) -> @587 (@588 (@574 @25 @27) @4) @592 +@605 := @597 @580 +@609 := @587 (@588 @576 @580) @592 +@610 := @97 @486 +@611 := LexLeanPreservation.Rust.FunSem +@612 := #9 +@618 := (n : @24) -> @611 @612 @114 @108 @4 @100 +@619 := @242 @501 +@620 := @241 @619 +@627 := LexLeanRuntime.index (@97 @501) @501 (LexLeanRuntime.instIndexableList @501) +@631 := @620 (@627 (@502 @612) @100) +@632 := @250 @501 +@633 := @632 @102 +@634 := @631 @633 +@635 := #10 +@639 := @69 @635 @612 @114 @102 +@640 := LexLeanTarget.TargetSyntax.Function.types +@641 := @640 @100 +@642 := @639 @641 +@643 := @242 @610 +@644 := @241 @643 +@645 := LexLeanTarget.TargetSemantics.bindAll +@646 := LexLeanTarget.TargetSyntax.Function.parameters +@651 := @644 (@645 (@646 @108) @100 @494) +@652 := @250 @610 +@653 := @652 @102 +@654 := @651 @653 +@655 := @242 @584 +@656 := @241 @655 +@657 := LexLeanPreservation.Rust.fnFallible +@658 := #11 +@661 := @656 (@657 @658 @612) +@662 := @250 @584 +@663 := @662 @102 +@664 := @661 @663 +@665 := LexLeanPreservation.RunConv +@666 := #13 +@670 := @665 @666 @635 @114 @102 +@672 := @587 @100 @592 +@673 := Exists.{1} +@674 := LexLeanPreservation.Rust.ROut +@675 := @673 @674 +@676 := And +@677 := LexLeanPreservation.Rust.RealizesFn +@681 := @676 (@677 @612 @114 @4) +@682 := LexLeanPreservation.Rust.RCI +@684 := @682 #15 +@685 := LexLeanPreservation.Rust.fnIdent +@686 := @685 @666 +@693 := (hne : @672) -> @675 (fun (ro : @674) => @681 (@684 @686 @658 @4)) +@708 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {f : @24} -> + {fn : @501} -> + {args : @98} -> + {env : @610} -> + {F : @584} -> + {o : @586} -> + (hB : @618) -> + (hfn : @634) -> (hwt : @642) -> (hbind : @654) -> (hF : @664) -> (hA : @670) -> @693 +@710 := LexLeanPreservation.Rust.compose @0 +@711 := @611 @0 +@716 := (n : @24) -> @711 @114 @108 @4 @100 +@717 := @627 @503 +@720 := @620 (@717 @100) @633 +@724 := @80 @612 @114 @102 @641 +@725 := @665 @0 +@728 := @725 @635 @114 @102 +@742 := {c : @22} -> + {A : @23} -> + {f : @24} -> + {fn : @501} -> + {args : @98} -> + {env : @610} -> + {F : @584} -> + {o : @586} -> + (hB : @716) -> + (hfn : @720) -> (hwt : @724) -> (hbind : @654) -> (hF : @664) -> (hA : @728) -> @693 +@743 := @710 @1 +@744 := @711 @1 +@748 := (n : @24) -> @744 @108 @4 @100 +@751 := @88 @114 @102 @641 +@752 := @657 @1 +@755 := @656 (@752 @612) @663 +@756 := @682 @1 +@766 := (hbind : @654) -> + (hF : @755) -> (hA : @728) -> (hne : @672) -> @675 (fun (ro : @674) => @681 (@756 @686 @658 @4)) +@776 := {A : @23} -> + {f : @24} -> + {fn : @501} -> + {args : @98} -> + {env : @610} -> {F : @584} -> {o : @586} -> (hB : @748) -> (hfn : @720) -> (hwt : @751) -> @766 +@777 := @743 @2 +@779 := @744 @2 @4 +@781 := (n : @24) -> @779 @100 +@782 := @94 @102 +@783 := @782 @641 +@792 := {f : @24} -> + {fn : @501} -> + {args : @98} -> + {env : @610} -> {F : @584} -> {o : @586} -> (hB : @781) -> (hfn : @720) -> (hwt : @783) -> @766 +@793 := @777 @9 +@795 := (n : @24) -> @779 @9 +@796 := @717 @9 +@797 := @620 @796 +@798 := @797 @633 +@799 := @752 @9 +@800 := @656 @799 +@801 := @800 @663 +@802 := @725 @9 +@804 := @802 @114 @102 +@806 := @756 (@685 @9) +@814 := (hF : @801) -> (hA : @804) -> (hne : @672) -> @675 (fun (ro : @674) => @681 (@806 @658 @4)) +@823 := {fn : @501} -> + {args : @98} -> + {env : @610} -> + {F : @584} -> {o : @586} -> (hB : @795) -> (hfn : @798) -> (hwt : @783) -> (hbind : @654) -> @814 +@824 := @793 @519 +@826 := @797 (@632 @519) +@827 := @640 @519 +@828 := @782 @827 +@830 := @645 (@646 @519) +@842 := {args : @98} -> + {env : @610} -> + {F : @584} -> + {o : @586} -> + (hB : @795) -> (hfn : @826) -> (hwt : @828) -> (hbind : @644 (@830 @100 @494) @653) -> @814 +@843 := @824 @400 +@845 := @541 (@370 @61) +@847 := @94 @845 @827 +@849 := @62 (@18 @114) +@851 := @849 (@541 @61) +@855 := @644 (@830 @851 @494) @653 +@857 := @62 (@18 @635) +@859 := @62 (@18 @612) +@861 := @857 (@859 @61) +@863 := @802 @861 @102 +@865 := @62 (@18 @666) +@868 := @62 (@18 #12) +@885 := {env : @610} -> + {F : @584} -> + {o : @586} -> + (hB : @795) -> + (hfn : @826) -> + (hwt : @847) -> + (hbind : @855) -> + (hF : @801) -> + (hA : @863) -> (hne : @672) -> @675 (fun (ro : @674) => @681 (@806 (@865 (@868 @61)) @4)) +@886 := @843 @499 +@888 := @370 (@190 @61) +@890 := @94 @888 @827 +@901 := @644 (@830 @845 @494) (@652 (@495 (@490 @369) (@495 (@492 @540) @494))) +@903 := @859 (@849 @61) +@905 := @802 @903 @102 +@907 := @62 (@18 @658) +@923 := {F : @584} -> + {o : @586} -> + (hB : @795) -> + (hfn : @826) -> + (hwt : @890) -> + (hbind : @901) -> + (hF : @801) -> + (hA : @905) -> (hne : @672) -> @675 (fun (ro : @674) => @681 (@806 (@868 (@907 @61)) @4)) +@924 := @886 @500 +@925 := @560 @827 +@936 := @644 (@830 @888 @494) (@652 (@495 (@490 @189) (@495 (@492 @369) @494))) +@938 := @800 (@662 @500) +@940 := @802 @851 @102 +@941 := @677 @500 +@959 := {o : @586} -> + (hB : @795) -> + (hfn : @826) -> + (hwt : @925) -> + (hbind : @936) -> + (hF : @938) -> + (hA : @940) -> + (hne : @672) -> @675 (fun (ro : @674) => @676 (@941 @114 @4) (@806 (@907 (@857 @61)) @4)) +@960 := @924 @573 +@961 := @388 @827 +@972 := @644 (@830 @559 @494) (@652 (@495 (@490 @203) (@495 (@492 @189) @494))) +@973 := @802 @845 +@975 := @571 @108 @100 +@976 := @973 @975 +@978 := @571 @114 @108 +@997 := (hB : @795) -> + (hfn : @826) -> + (hwt : @961) -> + (hbind : @972) -> + (hF : @938) -> + (hA : @976) -> + (hne : @587 @978 @592) -> @675 (fun (ro : @674) => @676 (@941 (@571 @635 @612) @4) (@806 @861 @4)) +@998 := @960 @523 +@999 := @395 @827 +@1010 := @644 (@830 @387 @494) (@652 (@495 (@490 @186) (@495 (@492 @203) @494))) +@1011 := @802 @888 +@1013 := @571 @100 @102 +@1032 := (hfn : @826) -> + (hwt : @999) -> + (hbind : @1010) -> + (hF : @938) -> + (hA : @1011 @1013) -> + (hne : @587 @975 @592) -> @675 (fun (ro : @674) => @676 (@941 (@571 @612 @114) @4) (@806 @903 @4)) +@1035 := @998 (@350 @619 @796) +@1036 := @401 @827 +@1047 := @644 (@830 @394 @494) (@652 (@495 (@490 @200) (@495 (@492 @186) @494))) +@1048 := @802 @559 +@1050 := @571 @102 @104 +@1066 := (hwt : @1036) -> + (hbind : @1047) -> + (hF : @938) -> + (hA : @1048 @1050) -> + (hne : @587 @1013 @592) -> @675 (fun (ro : @674) => @676 (@941 @978 @4) (@806 @851 @4)) +@1067 := @1035 @570 +@1069 := @830 @400 @494 +@1072 := @644 @1069 (@652 @499) +@1073 := @802 @387 +@1075 := @571 @104 @25 +@1090 := (hbind : @1072) -> + (hF : @938) -> + (hA : @1073 @1075) -> + (hne : @587 @1050 @592) -> @675 (fun (ro : @674) => @676 (@941 @975 @4) (@806 @845 @4)) +@1093 := @1067 (@350 @643 @1069) +@1094 := @802 @394 +@1096 := @571 @25 @27 +@1110 := (hF : @938) -> + (hA : @1094 @1096) -> + (hne : @587 @1075 @592) -> @675 (fun (ro : @674) => @676 (@941 @1013 @4) (@806 @888 @4)) +@1113 := @1093 (@350 @655 @799) +@1127 := (hA : @802 @400 @573) -> + (hne : @587 @1096 @592) -> @675 (fun (ro : @674) => @676 (@941 @1050 @4) (@806 @559 @4)) +@1128 := @1113 @583 +@1139 := (hne : @587 @573 @592) -> @675 (fun (ro : @674) => @676 (@941 @1075 @4) (@806 @387 @4)) +@1140 := @1128 @605 +@1146 := @676 (@941 @1096 @4) (@806 @394 @4) +@1148 := @675 (fun (ro : @674) => @1146) +@1150 := @675 (fun (__e_ro : @674) => @1146) +@1152 := LexLeanPreservation.Rust.RepresentableL @364 +@1153 := (__e_hrep : @1152) -> @1150 +@1154 := fun (__e_hrep : @1152) => @1140 +@1155 := (h : @24) -> @1153 +@1156 := fun (h : @24) => @1154 +@1157 := (w : @24) -> @1155 +@1158 := fun (w : @24) => @1156 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R13/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R13/Compose/RustStd.lean deleted file mode 100644 index 6e29f3850..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R13/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Coverage.Types.Tree)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.__enc_0 __v) (.adt 0) - | Coverage.Types.Tree.leaf => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Coverage.Types.Tree.node __x0 __x1 __x2 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x1) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 __x2) _root_.LexLeanPreservation.Rust.wtl_nil))) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (n : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat n) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R13/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R13/Compose/RustStd.lex.tex new file mode 100644 index 000000000..09e85eda9 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R13/Compose/RustStd.lex.tex @@ -0,0 +1,585 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd.__wt_0 : @520 := @519 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd.root : @1152 := @1153 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.flags +@3 := Coverage.Types.Tree +@4 := #0 +@5 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := fun (__v : @3) => @15 +@17 := LexLeanTarget.TargetSyntax.Value +@18 := LexLeanTarget.TargetSyntax.Ty +@19 := List.nil.{0} +@20 := List.cons.{0} +@21 := @19 @17 +@22 := @19 @18 +@23 := LexLeanTarget.TargetSyntax.Program +@24 := LexLeanPreservation.Rust.RCrate +@25 := LexLeanPreservation.Rust.Flags +@26 := LexLeanPreservation.Rust.WTL +@27 := #2 +@28 := @26 @27 +@29 := #1 +@36 := {p : @23} -> {c : @24} -> {A : @25} -> @28 @29 @4 @21 @22 +@38 := LexLeanPreservation.Rust.wtl_nil @0 +@39 := @26 @0 +@45 := {c : @24} -> {A : @25} -> @39 @29 @4 @21 @22 +@46 := @38 @1 +@47 := @39 @1 +@51 := {A : @25} -> @47 @4 @21 @22 +@52 := @46 @2 +@53 := @47 @2 +@54 := @53 @21 +@55 := @54 @22 +@56 := Nat +@57 := List.{0} +@58 := @57 @17 +@59 := @57 @18 +@60 := Eq.{1} +@61 := Option.{0} +@62 := @61 @59 +@63 := @60 @62 +@64 := LexLeanPreservation.Rust.adtFields +@65 := #6 +@66 := @64 @65 +@67 := #3 +@70 := @63 (@66 @67 @27) +@71 := Option.some.{0} +@72 := @71 @59 +@73 := @72 @4 +@74 := @70 @73 +@75 := #7 +@77 := @26 @75 @65 +@78 := #5 +@81 := @77 @78 @27 @29 +@82 := #8 +@85 := @7 @82 @75 @65 +@86 := LexLeanTarget.TargetSyntax.Value.adt +@87 := #4 +@89 := @86 @87 @67 +@90 := @85 @89 +@91 := @8 @78 +@101 := {p : @23} -> + {c : @24} -> + {A : @25} -> + {i : @56} -> {k : @56} -> {fs : @58} -> {tys : @59} -> (h : @74) -> (hf : @81) -> @90 @91 +@103 := LexLeanPreservation.Rust.wt_adt @0 +@104 := @64 @0 +@108 := @63 (@104 @67 @27) @73 +@112 := @39 @65 @78 @27 @29 +@124 := {c : @24} -> + {A : @25} -> + {i : @56} -> + {k : @56} -> {fs : @58} -> {tys : @59} -> (h : @108) -> (hf : @112) -> @11 @75 @65 @89 @91 +@125 := @103 @1 +@128 := @47 @78 @27 @29 +@138 := {A : @25} -> + {i : @56} -> + {k : @56} -> {fs : @58} -> {tys : @59} -> (h : @108) -> (hf : @128) -> @12 @65 @89 @91 +@139 := @125 @2 +@141 := @53 @27 @29 +@142 := @13 @89 +@149 := {i : @56} -> {k : @56} -> {fs : @58} -> {tys : @59} -> (h : @108) -> (hf : @141) -> @142 @91 +@150 := @139 @9 +@151 := @104 @9 +@160 := {k : @56} -> + {fs : @58} -> {tys : @59} -> (h : @63 (@151 @27) @73) -> (hf : @141) -> @142 @10 +@161 := @150 @9 +@162 := @151 @9 +@163 := @63 @162 +@164 := @163 @73 +@165 := @86 @9 +@172 := {fs : @58} -> {tys : @59} -> (h : @164) -> (hf : @141) -> @13 (@165 @67) @10 +@173 := @161 @21 +@174 := @54 @29 +@177 := @13 (@165 @21) @10 +@180 := {tys : @59} -> (h : @164) -> (hf : @174) -> @177 +@181 := @173 @22 +@185 := (h : @163 (@72 @22)) -> (hf : @55) -> @177 +@186 := Eq.refl.{1} +@187 := @186 @62 +@190 := @181 (@187 @162) @52 +@191 := @5 @87 +@192 := LexLeanTarget.TargetSyntax.Value.nat +@193 := @192 @67 +@194 := LexLeanTarget.TargetSyntax.Ty.nat +@197 := @7 @67 @27 @29 +@198 := @192 @4 +@204 := {p : @23} -> {c : @24} -> {A : @25} -> (n : @56) -> @197 @198 @194 +@206 := LexLeanPreservation.Rust.wt_nat @0 +@213 := {c : @24} -> {A : @25} -> (n : @56) -> @11 @27 @29 @198 @194 +@214 := @206 @1 +@219 := {A : @25} -> (n : @56) -> @12 @29 @198 @194 +@220 := @214 @2 +@223 := (n : @56) -> @13 @198 @194 +@224 := @220 @67 +@226 := @13 @193 @194 +@227 := @5 @27 +@228 := @20 @17 +@230 := @228 @227 @21 +@231 := @228 @193 +@232 := @231 @230 +@233 := @228 @191 +@234 := @233 @232 +@235 := @20 @18 +@236 := @235 @10 +@237 := @236 @22 +@238 := @235 @194 +@239 := @238 @237 +@240 := @236 @239 +@245 := @7 @65 @78 @87 @67 @27 +@248 := @26 @82 @75 @65 +@250 := @228 @78 @67 +@251 := @248 @250 +@253 := @235 @87 @27 +@263 := {p : @23} -> + {c : @24} -> + {A : @25} -> + {v : @17} -> {t : @18} -> {vs : @58} -> {ts : @59} -> (h : @245) -> (hs : @81) -> @251 @253 +@265 := LexLeanPreservation.Rust.wtl_cons @0 +@281 := {c : @24} -> + {A : @25} -> + {v : @17} -> + {t : @18} -> + {vs : @58} -> {ts : @59} -> (h : @11 @78 @87 @67 @27) -> (hs : @112) -> @39 @75 @65 @250 @253 +@282 := @265 @1 +@295 := {A : @25} -> + {v : @17} -> + {t : @18} -> {vs : @58} -> {ts : @59} -> (h : @12 @87 @67 @27) -> (hs : @128) -> @47 @65 @250 @253 +@296 := @282 @2 +@306 := {v : @17} -> + {t : @18} -> {vs : @58} -> {ts : @59} -> (h : @13 @67 @27) -> (hs : @141) -> @53 @250 @253 +@307 := @296 @227 +@308 := @5 @78 +@309 := @13 @308 +@310 := @309 @27 +@311 := @5 @75 +@312 := @228 @311 +@320 := {t : @18} -> {vs : @58} -> {ts : @59} -> (h : @310) -> (hs : @141) -> @53 (@312 @67) @253 +@321 := @307 @10 +@323 := @13 @191 @10 +@324 := @5 @65 +@325 := @228 @324 +@327 := @53 (@325 @67) +@328 := @236 @27 +@333 := {vs : @58} -> {ts : @59} -> (h : @323) -> (hs : @141) -> @327 @328 +@334 := @321 @21 +@335 := @5 @67 +@337 := @13 @335 @10 +@338 := @228 @308 +@339 := @338 @21 +@344 := {ts : @59} -> (h : @337) -> (hs : @174) -> @53 @339 @328 +@345 := @334 @22 +@347 := @13 @227 @10 +@348 := @233 @21 +@349 := @53 @348 +@352 := (h : @347) -> (hs : @55) -> @349 @237 +@353 := @345 @4 +@355 := @228 @335 @21 +@357 := @53 @355 @237 +@358 := (hs : @55) -> @357 +@359 := @353 @52 +@361 := @53 @230 @237 +@362 := @296 @193 +@363 := @192 @65 +@365 := @13 @363 @27 +@367 := @228 (@192 @82) +@375 := {t : @18} -> {vs : @58} -> {ts : @59} -> (h : @365) -> (hs : @141) -> @53 (@367 @67) @253 +@376 := @362 @194 +@377 := @192 @78 +@379 := @13 @377 @194 +@381 := @228 (@192 @75) +@383 := @53 (@381 @67) +@384 := @238 @27 +@389 := {vs : @58} -> {ts : @59} -> (h : @379) -> (hs : @141) -> @383 @384 +@390 := @376 @230 +@391 := @192 @87 +@392 := @13 @391 +@393 := @392 @194 +@394 := @349 @29 +@395 := @228 @363 +@396 := @395 @339 +@401 := {ts : @59} -> (h : @393) -> (hs : @394) -> @53 @396 @384 +@402 := @390 @237 +@403 := @228 @377 +@404 := @403 @348 +@405 := @53 @404 +@408 := (h : @226) -> (hs : @357) -> @405 @239 +@409 := @402 @224 +@410 := @228 @391 +@411 := @410 @355 +@413 := @53 @411 @239 +@414 := (hs : @361) -> @413 +@415 := @409 @359 +@417 := @53 @232 @239 +@418 := @296 @191 +@420 := @13 @311 @27 +@421 := #9 +@431 := {t : @18} -> + {vs : @58} -> {ts : @59} -> (h : @420) -> (hs : @141) -> @53 (@228 (@5 @421) @67) @253 +@432 := @418 @10 +@443 := {vs : @58} -> + {ts : @59} -> (h : @13 @324 @10) -> (hs : @141) -> @53 (@228 (@5 @82) @67) @328 +@444 := @432 @232 +@445 := @309 @10 +@446 := @405 @29 +@447 := @312 @396 +@452 := {ts : @59} -> (h : @445) -> (hs : @446) -> @53 @447 @328 +@453 := @444 @239 +@454 := @325 @404 +@455 := @53 @454 +@458 := (h : @323) -> (hs : @413) -> @455 @240 +@459 := @453 @29 +@460 := @338 @411 +@462 := @53 @460 @240 +@463 := (hs : @417) -> @462 +@464 := @459 @415 +@466 := @53 @234 @240 +@467 := 1 +@468 := @150 @467 +@469 := @151 @467 +@470 := @63 @469 +@471 := @470 @73 +@472 := @86 @467 +@479 := {fs : @58} -> {tys : @59} -> (h : @471) -> (hf : @141) -> @13 (@472 @67) @10 +@480 := @468 @234 +@487 := {tys : @59} -> (h : @471) -> (hf : @455 @29) -> @13 (@472 @447) @10 +@488 := @480 @240 +@495 := (h : @470 (@72 @240)) -> (hf : @462) -> @13 (@472 @454) @10 +@497 := @488 (@187 @469) +@501 := (hf : @466) -> @13 (@472 @460) @10 +@502 := @497 @464 +@505 := @13 (@472 @234) @10 +@513 := fun (__x0 : @3) => + fun (__x1 : @56) => + fun (__x2 : @3) => fun (__ih0 : @347) => fun (__ih1 : @13 (@5 @29) @10) => @502 +@519 := fun (__v : @3) => Coverage.Types.Tree.rec.{0} @16 @190 @513 @4 +@520 := (__v : @3) -> @15 +@521 := @192 @29 +@522 := @220 @29 +@524 := @13 @521 @194 +@526 := @228 @521 @21 +@529 := Prod.{0, 0} @56 @17 +@533 := Prod.mk.{0, 0} @56 @17 @9 +@534 := @533 @521 +@535 := @19 @529 +@536 := @20 @529 +@538 := @536 @534 @535 +@539 := Bool.true +@540 := LexLeanTarget.TargetSyntax.Function +@541 := LexLeanTarget.TargetSyntax.Program.functions +@542 := @541 @0 +@543 := @19 @56 +@544 := LexLeanTarget.TargetSyntax.Ty.unit +@545 := LexLeanTarget.TargetSyntax.Value.unit +@548 := LexLeanTarget.TargetSyntax.Expr.value @544 @545 +@553 := LexLeanTarget.TargetSyntax.Function.mk @543 @22 @544 @548 +@558 := List.getD.{0} @540 @542 @9 @553 +@562 := fun (__e_n : @56) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.root @4 @9 +@563 := @296 @521 +@572 := {t : @18} -> + {vs : @58} -> {ts : @59} -> (h : @392 @27) -> (hs : @141) -> @53 (@395 @67) @253 +@573 := @563 @194 +@580 := {vs : @58} -> {ts : @59} -> (h : @226) -> (hs : @141) -> @53 (@403 @67) @384 +@581 := @573 @21 +@582 := @192 @27 +@584 := @13 @582 @194 +@585 := @410 @21 +@586 := @53 @585 +@590 := {ts : @59} -> (h : @584) -> (hs : @174) -> @586 @384 +@591 := @581 @22 +@592 := @231 @21 +@593 := @53 @592 +@594 := @238 @22 +@597 := (h : @524) -> (hs : @55) -> @593 @594 +@598 := @591 @522 +@600 := @228 @582 @21 +@601 := @53 @600 +@603 := (hs : @55) -> @601 @594 +@604 := @598 @52 +@605 := @53 @526 +@606 := @605 @594 +@607 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.denote +@608 := @607 @29 +@609 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.__fits_0 +@610 := @609 @29 +@613 := @192 (Coverage.Main.treeTotal @29) +@615 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.root @29 +@616 := Bool +@617 := Ne.{1} +@618 := LexLeanPreservation.Obs +@619 := @617 @618 +@620 := LexLeanPreservation.Rel +@623 := @619 (@620 @29 @4) +@624 := LexLeanPreservation.Obs.stuck +@627 := (f : @616) -> (v : @17) -> @623 @624 +@629 := LexLeanPreservation.Rust.rel_ne_stuck @610 +@635 := (v : @17) -> @619 (@620 (@609 @27) @4) @624 +@636 := @629 @613 +@640 := @619 (@620 @610 @613) @624 +@641 := @57 @529 +@642 := LexLeanPreservation.Rust.FunSem +@648 := (n : @56) -> @642 @421 @82 @75 @4 @65 +@649 := @61 @540 +@650 := @60 @649 +@657 := LexLeanRuntime.index (@57 @540) @540 (LexLeanRuntime.instIndexableList @540) +@661 := @650 (@657 (@541 @421) @65) +@662 := @71 @540 +@663 := @662 @78 +@664 := @661 @663 +@665 := #10 +@669 := @26 @665 @421 @82 @78 +@670 := LexLeanTarget.TargetSyntax.Function.types +@671 := @670 @65 +@672 := @669 @671 +@673 := @61 @641 +@674 := @60 @673 +@675 := LexLeanTarget.TargetSemantics.bindAll +@676 := LexLeanTarget.TargetSyntax.Function.parameters +@681 := @674 (@675 (@676 @75) @65 @535) +@682 := @71 @641 +@683 := @682 @78 +@684 := @681 @683 +@685 := @61 @616 +@686 := @60 @685 +@687 := LexLeanPreservation.Rust.fnFallible +@688 := #11 +@691 := @686 (@687 @688 @421) +@692 := @71 @616 +@693 := @692 @78 +@694 := @691 @693 +@695 := LexLeanPreservation.RunConv +@696 := #13 +@700 := @695 @696 @665 @82 @78 +@702 := @619 @65 @624 +@703 := Exists.{1} +@704 := LexLeanPreservation.Rust.ROut +@705 := @703 @704 +@706 := And +@707 := LexLeanPreservation.Rust.RealizesFn +@711 := @706 (@707 @421 @82 @4) +@712 := LexLeanPreservation.Rust.RCI +@714 := @712 #15 +@715 := LexLeanPreservation.Rust.fnIdent +@716 := @715 @696 +@723 := (hne : @702) -> @705 (fun (ro : @704) => @711 (@714 @716 @688 @4)) +@738 := {p : @23} -> + {c : @24} -> + {A : @25} -> + {f : @56} -> + {fn : @540} -> + {args : @58} -> + {env : @641} -> + {F : @616} -> + {o : @618} -> + (hB : @648) -> + (hfn : @664) -> (hwt : @672) -> (hbind : @684) -> (hF : @694) -> (hA : @700) -> @723 +@740 := LexLeanPreservation.Rust.compose @0 +@741 := @642 @0 +@746 := (n : @56) -> @741 @82 @75 @4 @65 +@747 := @657 @542 +@750 := @650 (@747 @65) @663 +@754 := @39 @421 @82 @78 @671 +@755 := @695 @0 +@758 := @755 @665 @82 @78 +@772 := {c : @24} -> + {A : @25} -> + {f : @56} -> + {fn : @540} -> + {args : @58} -> + {env : @641} -> + {F : @616} -> + {o : @618} -> + (hB : @746) -> + (hfn : @750) -> (hwt : @754) -> (hbind : @684) -> (hF : @694) -> (hA : @758) -> @723 +@773 := @740 @1 +@774 := @741 @1 +@778 := (n : @56) -> @774 @75 @4 @65 +@781 := @47 @82 @78 @671 +@782 := @687 @1 +@785 := @686 (@782 @421) @693 +@786 := @712 @1 +@796 := (hbind : @684) -> + (hF : @785) -> (hA : @758) -> (hne : @702) -> @705 (fun (ro : @704) => @711 (@786 @716 @688 @4)) +@806 := {A : @25} -> + {f : @56} -> + {fn : @540} -> + {args : @58} -> + {env : @641} -> {F : @616} -> {o : @618} -> (hB : @778) -> (hfn : @750) -> (hwt : @781) -> @796 +@807 := @773 @2 +@809 := @774 @2 @4 +@811 := (n : @56) -> @809 @65 +@812 := @53 @78 +@813 := @812 @671 +@822 := {f : @56} -> + {fn : @540} -> + {args : @58} -> + {env : @641} -> {F : @616} -> {o : @618} -> (hB : @811) -> (hfn : @750) -> (hwt : @813) -> @796 +@823 := @807 @9 +@825 := (n : @56) -> @809 @9 +@826 := @747 @9 +@827 := @650 @826 +@828 := @827 @663 +@829 := @782 @9 +@830 := @686 @829 +@831 := @830 @693 +@832 := @755 @9 +@834 := @832 @82 @78 +@836 := @786 (@715 @9) +@844 := (hF : @831) -> (hA : @834) -> (hne : @702) -> @705 (fun (ro : @704) => @711 (@836 @688 @4)) +@853 := {fn : @540} -> + {args : @58} -> + {env : @641} -> + {F : @616} -> {o : @618} -> (hB : @825) -> (hfn : @828) -> (hwt : @813) -> (hbind : @684) -> @844 +@854 := @823 @558 +@856 := @827 (@662 @558) +@857 := @670 @558 +@858 := @812 @857 +@860 := @675 (@676 @558) +@872 := {args : @58} -> + {env : @641} -> + {F : @616} -> + {o : @618} -> + (hB : @825) -> (hfn : @856) -> (hwt : @858) -> (hbind : @674 (@860 @65 @535) @683) -> @844 +@873 := @854 @526 +@874 := @395 @21 +@876 := @53 @874 @857 +@877 := @381 @21 +@881 := @674 (@860 @877 @535) @683 +@884 := @228 (@192 @421) @21 +@905 := {env : @641} -> + {F : @616} -> + {o : @618} -> + (hB : @825) -> + (hfn : @856) -> + (hwt : @876) -> + (hbind : @881) -> + (hF : @831) -> + (hA : @832 @884 @78) -> + (hne : @702) -> @705 (fun (ro : @704) => @711 (@836 (@228 (@192 #12) @21) @4)) +@906 := @873 @538 +@907 := @403 @21 +@909 := @53 @907 @857 +@917 := @674 (@860 @874 @535) (@682 (@536 (@533 @363) @535)) +@918 := @367 @21 +@937 := {F : @616} -> + {o : @618} -> + (hB : @825) -> + (hfn : @856) -> + (hwt : @909) -> + (hbind : @917) -> + (hF : @831) -> + (hA : @832 @918 @78) -> + (hne : @702) -> @705 (fun (ro : @704) => @711 (@836 (@228 (@192 @688) @21) @4)) +@938 := @906 @539 +@939 := @586 @857 +@947 := @674 (@860 @907 @535) (@682 (@536 (@533 @377) @535)) +@949 := @830 (@692 @539) +@951 := @832 @877 @78 +@952 := @707 @539 +@971 := {o : @618} -> + (hB : @825) -> + (hfn : @856) -> + (hwt : @939) -> + (hbind : @947) -> + (hF : @949) -> + (hA : @951) -> + (hne : @702) -> @705 (fun (ro : @704) => @706 (@952 @82 @4) (@836 (@228 (@192 @665) @21) @4)) +@972 := @938 @608 +@973 := @593 @857 +@981 := @674 (@860 @585 @535) (@682 (@536 (@533 @391) @535)) +@982 := @832 @874 +@983 := @607 @65 +@984 := @982 @983 +@985 := @607 @75 +@1003 := (hB : @825) -> + (hfn : @856) -> + (hwt : @973) -> + (hbind : @981) -> + (hF : @949) -> + (hA : @984) -> + (hne : @619 @985 @624) -> @705 (fun (ro : @704) => @706 (@952 (@607 @421) @4) (@836 @884 @4)) +@1004 := @972 @562 +@1005 := @601 @857 +@1013 := @674 (@860 @592 @535) (@682 (@536 (@533 @193) @535)) +@1014 := @832 @907 +@1015 := @607 @78 +@1033 := (hfn : @856) -> + (hwt : @1005) -> + (hbind : @1013) -> + (hF : @949) -> + (hA : @1014 @1015) -> + (hne : @619 @983 @624) -> @705 (fun (ro : @704) => @706 (@952 (@607 @82) @4) (@836 @918 @4)) +@1036 := @1004 (@186 @649 @826) +@1037 := @605 @857 +@1045 := @674 (@860 @600 @535) (@682 (@536 (@533 @582) @535)) +@1046 := @832 @585 +@1047 := @607 @87 +@1063 := (hwt : @1037) -> + (hbind : @1045) -> + (hF : @949) -> + (hA : @1046 @1047) -> + (hne : @619 @1015 @624) -> @705 (fun (ro : @704) => @706 (@952 @985 @4) (@836 @877 @4)) +@1064 := @1036 @604 +@1066 := @860 @526 @535 +@1069 := @674 @1066 (@682 @538) +@1070 := @832 @592 +@1071 := @607 @67 +@1086 := (hbind : @1069) -> + (hF : @949) -> + (hA : @1070 @1071) -> + (hne : @619 @1047 @624) -> @705 (fun (ro : @704) => @706 (@952 @983 @4) (@836 @874 @4)) +@1089 := @1064 (@186 @673 @1066) +@1090 := @832 @600 +@1091 := @607 @27 +@1105 := (hF : @949) -> + (hA : @1090 @1091) -> + (hne : @619 @1071 @624) -> @705 (fun (ro : @704) => @706 (@952 @1015 @4) (@836 @907 @4)) +@1108 := @1089 (@186 @685 @829) +@1122 := (hA : @832 @526 @608) -> + (hne : @619 @1091 @624) -> @705 (fun (ro : @704) => @706 (@952 @1047 @4) (@836 @585 @4)) +@1123 := @1108 @615 +@1134 := (hne : @619 @608 @624) -> @705 (fun (ro : @704) => @706 (@952 @1071 @4) (@836 @592 @4)) +@1135 := @1123 @636 +@1141 := @706 (@952 @1091 @4) (@836 @600 @4) +@1143 := @705 (fun (ro : @704) => @1141) +@1145 := @705 (fun (__e_ro : @704) => @1141) +@1149 := LexLeanPreservation.Rust.RepresentableL (@228 @198 @21) +@1150 := (__e_hrep : @1149) -> @1145 +@1151 := fun (__e_hrep : @1149) => @1135 +@1152 := (n : @56) -> @1150 +@1153 := fun (n : @56) => @1151 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustCore.lean deleted file mode 100644 index 320a78dad..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustCore.lean +++ /dev/null @@ -1,25 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore - -theorem __wt_0 : ∀ (__s : (Coverage.Types.Point)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_0 __s) (.adt 0) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).x) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).y) _root_.LexLeanPreservation.Rust.wtl_nil)) - -theorem __wt_1 : ∀ (__s : (Coverage.Types.Box Nat)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_1 __s) (.adt 1) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).content) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).count) _root_.LexLeanPreservation.Rust.wtl_nil)) - -theorem __wt_2 : ∀ (__s : (Coverage.Types.Weights)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_2 __s) (.adt 2) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).base) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).scale) _root_.LexLeanPreservation.Rust.wtl_nil)) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Nat) (b : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustCore.lex.tex new file mode 100644 index 000000000..c71171dae --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustCore.lex.tex @@ -0,0 +1,776 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_1 : @449 := @632 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_2 : @640 := @821 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.root : @1560 := @1561 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.flags +@3 := Coverage.Types.Point +@4 := #0 +@6 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_0 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@16 := (__s : @3) -> @13 @6 @10 +@17 := Coverage.Types.Point.x +@18 := @17 @4 +@19 := Coverage.Types.Point.y +@20 := @19 @4 +@21 := LexLeanTarget.TargetSyntax.Value.nat +@22 := @21 @18 +@23 := LexLeanTarget.TargetSyntax.Ty.nat +@24 := LexLeanTarget.TargetSyntax.Program +@25 := LexLeanPreservation.Rust.RCrate +@26 := LexLeanPreservation.Rust.Flags +@27 := Nat +@28 := #3 +@29 := @7 @28 +@30 := #2 +@31 := @29 @30 +@32 := #1 +@33 := @31 @32 +@34 := @21 @4 +@40 := {p : @24} -> {c : @25} -> {A : @26} -> (n : @27) -> @33 @34 @23 +@42 := LexLeanPreservation.Rust.wt_nat @0 +@49 := {c : @25} -> {A : @26} -> (n : @27) -> @11 @30 @32 @34 @23 +@50 := @42 @1 +@55 := {A : @26} -> (n : @27) -> @12 @32 @34 @23 +@56 := @50 @2 +@59 := (n : @27) -> @13 @34 @23 +@60 := @56 @18 +@62 := @13 @22 @23 +@63 := @21 @20 +@64 := @56 @20 +@66 := @13 @63 @23 +@67 := LexLeanTarget.TargetSyntax.Value +@68 := LexLeanTarget.TargetSyntax.Ty +@69 := List.nil.{0} +@70 := List.cons.{0} +@71 := @69 @67 +@72 := @70 @67 +@74 := @72 @63 @71 +@76 := @72 @22 @74 +@77 := @69 @68 +@78 := @70 @68 +@79 := @78 @23 +@80 := @79 @77 +@81 := @79 @80 +@82 := LexLeanPreservation.Rust.WTL +@90 := {p : @24} -> {c : @25} -> {A : @26} -> @82 @30 @32 @4 @71 @77 +@92 := LexLeanPreservation.Rust.wtl_nil @0 +@93 := @82 @0 +@99 := {c : @25} -> {A : @26} -> @93 @32 @4 @71 @77 +@100 := @92 @1 +@101 := @93 @1 +@105 := {A : @26} -> @101 @4 @71 @77 +@106 := @100 @2 +@107 := @101 @2 +@108 := @107 @71 +@109 := @108 @77 +@110 := List.{0} +@111 := @110 @67 +@112 := @110 @68 +@113 := #6 +@114 := @7 @113 +@115 := #5 +@116 := @114 @115 +@117 := #4 +@120 := @116 @117 @28 @30 +@121 := #7 +@126 := @82 @121 @113 @115 @30 @32 +@127 := #8 +@130 := @82 @127 @121 @113 +@132 := @72 @115 @28 +@133 := @130 @132 +@135 := @78 @117 @30 +@145 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {v : @67} -> {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @120) -> (hs : @126) -> @133 @135 +@147 := LexLeanPreservation.Rust.wtl_cons @0 +@151 := @11 @115 @117 @28 @30 +@155 := @93 @113 @115 @30 @32 +@167 := {c : @25} -> + {A : @26} -> + {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @151) -> (hs : @155) -> @93 @121 @113 @132 @135 +@168 := @147 @1 +@171 := @12 @117 @28 @30 +@174 := @101 @115 @30 @32 +@184 := {A : @26} -> + {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @171) -> (hs : @174) -> @101 @113 @132 @135 +@185 := @168 @2 +@187 := @13 @28 @30 +@189 := @107 @30 @32 +@197 := {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @187) -> (hs : @189) -> @107 @132 @135 +@198 := @185 @63 +@200 := @21 (@19 @28) +@213 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @200 @30) -> (hs : @189) -> @107 (@72 (@21 (@19 @115)) @28) @135 +@214 := @198 @23 +@216 := @21 (@19 @30) +@218 := @13 @216 @23 +@223 := @107 (@72 (@21 (@19 @117)) @28) +@224 := @79 @30 +@229 := {vs : @111} -> {ts : @112} -> (h : @218) -> (hs : @189) -> @223 @224 +@230 := @214 @71 +@232 := @21 (@19 @32) +@234 := @13 @232 @23 +@235 := @108 @32 +@237 := @72 @200 @71 +@242 := {ts : @112} -> (h : @234) -> (hs : @235) -> @107 @237 @224 +@243 := @230 @77 +@245 := @72 @216 @71 +@246 := @107 @245 +@249 := (h : @66) -> (hs : @109) -> @246 @80 +@250 := @243 @64 +@252 := @72 @232 @71 +@254 := @107 @252 @80 +@255 := (hs : @109) -> @254 +@256 := @250 @106 +@258 := @107 @74 @80 +@259 := @185 @22 +@261 := @21 (@17 @28) +@274 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @261 @30) -> (hs : @189) -> @107 (@72 (@21 (@17 @115)) @28) @135 +@275 := @259 @23 +@277 := @21 (@17 @30) +@289 := {vs : @111} -> + {ts : @112} -> (h : @13 @277 @23) -> (hs : @189) -> @107 (@72 (@21 (@17 @117)) @28) @224 +@290 := @275 @74 +@292 := @21 (@17 @32) +@294 := @13 @292 @23 +@295 := @246 @32 +@297 := @72 @261 @237 +@302 := {ts : @112} -> (h : @294) -> (hs : @295) -> @107 @297 @224 +@303 := @290 @80 +@305 := @72 @277 @245 +@306 := @107 @305 +@309 := (h : @62) -> (hs : @254) -> @306 @81 +@310 := @303 @60 +@312 := @72 @292 @252 +@314 := @107 @312 @81 +@315 := (hs : @258) -> @314 +@316 := @310 @256 +@318 := @107 @76 @81 +@319 := Eq.{1} +@320 := Option.{0} +@321 := @320 @112 +@322 := @319 @321 +@323 := LexLeanPreservation.Rust.adtFields +@327 := @322 (@323 @113 @28 @30) +@328 := Option.some.{0} +@329 := @328 @112 +@330 := @329 @4 +@331 := @327 @330 +@334 := @7 @127 @121 @113 +@335 := LexLeanTarget.TargetSyntax.Value.adt +@337 := @335 @117 @28 +@338 := @334 @337 +@339 := @8 @115 +@349 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {i : @27} -> {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @331) -> (hf : @126) -> @338 @339 +@351 := LexLeanPreservation.Rust.wt_adt @0 +@352 := @323 @0 +@356 := @322 (@352 @28 @30) @330 +@368 := {c : @25} -> + {A : @26} -> + {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @155) -> @11 @121 @113 @337 @339 +@369 := @351 @1 +@379 := {A : @26} -> + {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @174) -> @12 @113 @337 @339 +@380 := @369 @2 +@381 := @13 @337 +@388 := {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @189) -> @381 @339 +@389 := @380 @9 +@390 := @352 @9 +@399 := {k : @27} -> + {fs : @111} -> {tys : @112} -> (h : @322 (@390 @30) @330) -> (hf : @189) -> @381 @10 +@400 := @389 @9 +@401 := @390 @9 +@402 := @322 @401 +@403 := @402 @330 +@404 := @335 @9 +@406 := @13 (@404 @28) +@411 := {fs : @111} -> {tys : @112} -> (h : @403) -> (hf : @189) -> @406 @10 +@412 := @400 @76 +@419 := {tys : @112} -> (h : @403) -> (hf : @306 @32) -> @13 (@404 @297) @10 +@420 := @412 @81 +@421 := @329 @81 +@427 := (h : @402 @421) -> (hf : @314) -> @13 (@404 @305) @10 +@428 := Eq.refl.{1} +@429 := @428 @321 +@431 := @420 (@429 @401) +@435 := (hf : @318) -> @13 (@404 @312) @10 +@436 := @431 @316 +@439 := @13 (@404 @76) @10 +@440 := fun (__s : @3) => @436 +@442 := Coverage.Types.Box @27 +@444 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_1 @4 +@445 := 1 +@446 := @8 @445 +@449 := (__s : @442) -> @13 @444 @446 +@451 := Coverage.Types.Box.content @27 +@452 := @451 @4 +@454 := Coverage.Types.Box.count @27 +@455 := @454 @4 +@456 := @21 @452 +@457 := @56 @452 +@459 := @13 @456 @23 +@460 := @21 @455 +@461 := @56 @455 +@463 := @13 @460 @23 +@465 := @72 @460 @71 +@467 := @72 @456 @465 +@468 := @185 @460 +@470 := @21 (@454 @28) +@483 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @470 @30) -> (hs : @189) -> @107 (@72 (@21 (@454 @115)) @28) @135 +@484 := @468 @23 +@486 := @21 (@454 @30) +@498 := {vs : @111} -> + {ts : @112} -> (h : @13 @486 @23) -> (hs : @189) -> @107 (@72 (@21 (@454 @117)) @28) @224 +@499 := @484 @71 +@501 := @21 (@454 @32) +@503 := @13 @501 @23 +@505 := @72 @470 @71 +@510 := {ts : @112} -> (h : @503) -> (hs : @235) -> @107 @505 @224 +@511 := @499 @77 +@513 := @72 @486 @71 +@514 := @107 @513 +@517 := (h : @463) -> (hs : @109) -> @514 @80 +@518 := @511 @461 +@520 := @72 @501 @71 +@522 := @107 @520 @80 +@523 := (hs : @109) -> @522 +@524 := @518 @106 +@526 := @107 @465 @80 +@527 := @185 @456 +@529 := @21 (@451 @28) +@542 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @529 @30) -> (hs : @189) -> @107 (@72 (@21 (@451 @115)) @28) @135 +@543 := @527 @23 +@545 := @21 (@451 @30) +@557 := {vs : @111} -> + {ts : @112} -> (h : @13 @545 @23) -> (hs : @189) -> @107 (@72 (@21 (@451 @117)) @28) @224 +@558 := @543 @465 +@560 := @21 (@451 @32) +@562 := @13 @560 @23 +@563 := @514 @32 +@565 := @72 @529 @505 +@570 := {ts : @112} -> (h : @562) -> (hs : @563) -> @107 @565 @224 +@571 := @558 @80 +@573 := @72 @545 @513 +@574 := @107 @573 +@577 := (h : @459) -> (hs : @522) -> @574 @81 +@578 := @571 @457 +@580 := @72 @560 @520 +@582 := @107 @580 @81 +@583 := (hs : @526) -> @582 +@584 := @578 @524 +@586 := @107 @467 @81 +@587 := @380 @445 +@588 := @352 @445 +@597 := {k : @27} -> + {fs : @111} -> {tys : @112} -> (h : @322 (@588 @30) @330) -> (hf : @189) -> @381 @446 +@598 := @587 @9 +@599 := @588 @9 +@600 := @322 @599 +@601 := @600 @330 +@606 := {fs : @111} -> {tys : @112} -> (h : @601) -> (hf : @189) -> @406 @446 +@607 := @598 @467 +@614 := {tys : @112} -> (h : @601) -> (hf : @574 @32) -> @13 (@404 @565) @446 +@615 := @607 @81 +@621 := (h : @600 @421) -> (hf : @582) -> @13 (@404 @573) @446 +@623 := @615 (@429 @599) +@627 := (hf : @586) -> @13 (@404 @580) @446 +@628 := @623 @584 +@631 := @13 (@404 @467) @446 +@632 := fun (__s : @442) => @628 +@633 := Coverage.Types.Weights +@635 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_2 @4 +@636 := 2 +@637 := @8 @636 +@640 := (__s : @633) -> @13 @635 @637 +@641 := Coverage.Types.Weights.base +@642 := @641 @4 +@643 := Coverage.Types.Weights.scale +@644 := @643 @4 +@645 := @21 @642 +@646 := @56 @642 +@648 := @13 @645 @23 +@649 := @21 @644 +@650 := @56 @644 +@652 := @13 @649 @23 +@654 := @72 @649 @71 +@656 := @72 @645 @654 +@657 := @185 @649 +@659 := @21 (@643 @28) +@672 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @659 @30) -> (hs : @189) -> @107 (@72 (@21 (@643 @115)) @28) @135 +@673 := @657 @23 +@675 := @21 (@643 @30) +@687 := {vs : @111} -> + {ts : @112} -> (h : @13 @675 @23) -> (hs : @189) -> @107 (@72 (@21 (@643 @117)) @28) @224 +@688 := @673 @71 +@690 := @21 (@643 @32) +@692 := @13 @690 @23 +@694 := @72 @659 @71 +@699 := {ts : @112} -> (h : @692) -> (hs : @235) -> @107 @694 @224 +@700 := @688 @77 +@702 := @72 @675 @71 +@703 := @107 @702 +@706 := (h : @652) -> (hs : @109) -> @703 @80 +@707 := @700 @650 +@709 := @72 @690 @71 +@711 := @107 @709 @80 +@712 := (hs : @109) -> @711 +@713 := @707 @106 +@715 := @107 @654 @80 +@716 := @185 @645 +@718 := @21 (@641 @28) +@731 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @718 @30) -> (hs : @189) -> @107 (@72 (@21 (@641 @115)) @28) @135 +@732 := @716 @23 +@734 := @21 (@641 @30) +@746 := {vs : @111} -> + {ts : @112} -> (h : @13 @734 @23) -> (hs : @189) -> @107 (@72 (@21 (@641 @117)) @28) @224 +@747 := @732 @654 +@749 := @21 (@641 @32) +@751 := @13 @749 @23 +@752 := @703 @32 +@754 := @72 @718 @694 +@759 := {ts : @112} -> (h : @751) -> (hs : @752) -> @107 @754 @224 +@760 := @747 @80 +@762 := @72 @734 @702 +@763 := @107 @762 +@766 := (h : @648) -> (hs : @711) -> @763 @81 +@767 := @760 @646 +@769 := @72 @749 @709 +@771 := @107 @769 @81 +@772 := (hs : @715) -> @771 +@773 := @767 @713 +@775 := @107 @656 @81 +@776 := @380 @636 +@777 := @352 @636 +@786 := {k : @27} -> + {fs : @111} -> {tys : @112} -> (h : @322 (@777 @30) @330) -> (hf : @189) -> @381 @637 +@787 := @776 @9 +@788 := @777 @9 +@789 := @322 @788 +@790 := @789 @330 +@795 := {fs : @111} -> {tys : @112} -> (h : @790) -> (hf : @189) -> @406 @637 +@796 := @787 @656 +@803 := {tys : @112} -> (h : @790) -> (hf : @763 @32) -> @13 (@404 @754) @637 +@804 := @796 @81 +@810 := (h : @789 @421) -> (hf : @771) -> @13 (@404 @762) @637 +@812 := @804 (@429 @788) +@816 := (hf : @775) -> @13 (@404 @769) @637 +@817 := @812 @773 +@820 := @13 (@404 @656) @637 +@821 := fun (__s : @633) => @817 +@822 := @21 @30 +@823 := @56 @30 +@825 := @13 @822 @23 +@826 := @21 @32 +@827 := @56 @32 +@829 := @13 @826 @23 +@830 := @72 @826 +@831 := @830 @71 +@832 := @72 @822 +@833 := @832 @831 +@836 := Prod.{0, 0} @27 @67 +@839 := Prod.mk.{0, 0} @27 @67 +@840 := @839 @445 +@841 := @840 @826 +@842 := @839 @9 +@843 := @842 @822 +@844 := @69 @836 +@845 := @70 @836 +@847 := @845 @843 @844 +@849 := @845 @841 @847 +@850 := Bool.true +@851 := LexLeanTarget.TargetSyntax.Function +@852 := LexLeanTarget.TargetSyntax.Program.functions +@853 := @852 @0 +@854 := @69 @27 +@855 := LexLeanTarget.TargetSyntax.Ty.unit +@856 := LexLeanTarget.TargetSyntax.Value.unit +@859 := LexLeanTarget.TargetSyntax.Expr.value @855 @856 +@864 := LexLeanTarget.TargetSyntax.Function.mk @854 @77 @855 @859 +@869 := List.getD.{0} @851 @853 @9 @864 +@873 := fun (__e_n : @27) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.root @4 @9 +@874 := @185 @826 +@875 := @21 @117 +@876 := @13 @875 +@877 := @876 @30 +@878 := @21 @113 +@879 := @72 @878 +@881 := @107 (@879 @28) +@887 := {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @877) -> (hs : @189) -> @881 @135 +@888 := @874 @23 +@889 := @21 @28 +@891 := @13 @889 @23 +@892 := @21 @115 +@893 := @72 @892 +@900 := {vs : @111} -> {ts : @112} -> (h : @891) -> (hs : @189) -> @107 (@893 @28) @224 +@901 := @888 @71 +@902 := @72 @875 +@903 := @902 @71 +@908 := {ts : @112} -> (h : @825) -> (hs : @235) -> @107 @903 @224 +@909 := @901 @77 +@910 := @72 @889 +@911 := @910 @71 +@912 := @107 @911 +@915 := (h : @829) -> (hs : @109) -> @912 @80 +@916 := @909 @827 +@917 := @832 @71 +@919 := @107 @917 @80 +@920 := (hs : @109) -> @919 +@921 := @916 @106 +@923 := @107 @831 @80 +@924 := @185 @822 +@926 := @13 @892 @30 +@927 := @21 @121 +@928 := @72 @927 +@936 := {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @926) -> (hs : @189) -> @107 (@928 @28) @135 +@937 := @924 @23 +@943 := {vs : @111} -> {ts : @112} -> (h : @876 @23) -> (hs : @189) -> @881 @224 +@944 := @937 @831 +@945 := @912 @32 +@946 := @893 @903 +@947 := @107 @946 +@951 := {ts : @112} -> (h : @891) -> (hs : @945) -> @947 @224 +@952 := @944 @80 +@953 := @902 @911 +@954 := @107 @953 +@957 := (h : @825) -> (hs : @919) -> @954 @81 +@958 := @952 @823 +@959 := @910 @917 +@960 := @107 @959 +@962 := (hs : @923) -> @960 @81 +@963 := @958 @921 +@964 := @107 @833 +@965 := @964 @81 +@966 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.denote +@968 := @966 @30 @32 +@969 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__fits_0 +@971 := @969 @30 @32 +@974 := Coverage.Main.records @30 @32 +@980 := LexLeanPreservation.encPair @27 @27 @21 @21 @974 +@983 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.root @30 @32 +@984 := Bool +@985 := Ne.{1} +@986 := LexLeanPreservation.Obs +@987 := @985 @986 +@988 := LexLeanPreservation.Rel +@991 := @987 (@988 @32 @4) +@992 := LexLeanPreservation.Obs.stuck +@995 := (f : @984) -> (v : @67) -> @991 @992 +@997 := LexLeanPreservation.Rust.rel_ne_stuck @971 +@1004 := (v : @67) -> @987 (@988 (@969 @28 @30) @4) @992 +@1005 := @997 @980 +@1009 := @987 (@988 @971 @980) @992 +@1010 := @110 @836 +@1011 := LexLeanPreservation.Rust.FunSem +@1012 := #9 +@1018 := (n : @27) -> @1011 @1012 @127 @121 @4 @113 +@1019 := @320 @851 +@1020 := @319 @1019 +@1027 := LexLeanRuntime.index (@110 @851) @851 (LexLeanRuntime.instIndexableList @851) +@1031 := @1020 (@1027 (@852 @1012) @113) +@1032 := @328 @851 +@1033 := @1032 @115 +@1034 := @1031 @1033 +@1035 := #10 +@1039 := @82 @1035 @1012 @127 @115 +@1040 := LexLeanTarget.TargetSyntax.Function.types +@1041 := @1040 @113 +@1042 := @1039 @1041 +@1043 := @320 @1010 +@1044 := @319 @1043 +@1045 := LexLeanTarget.TargetSemantics.bindAll +@1046 := LexLeanTarget.TargetSyntax.Function.parameters +@1051 := @1044 (@1045 (@1046 @121) @113 @844) +@1052 := @328 @1010 +@1053 := @1052 @115 +@1054 := @1051 @1053 +@1055 := @320 @984 +@1056 := @319 @1055 +@1057 := LexLeanPreservation.Rust.fnFallible +@1058 := #11 +@1061 := @1056 (@1057 @1058 @1012) +@1062 := @328 @984 +@1063 := @1062 @115 +@1064 := @1061 @1063 +@1065 := LexLeanPreservation.RunConv +@1066 := #13 +@1070 := @1065 @1066 @1035 @127 @115 +@1072 := @987 @113 @992 +@1073 := Exists.{1} +@1074 := LexLeanPreservation.Rust.ROut +@1075 := @1073 @1074 +@1076 := And +@1077 := LexLeanPreservation.Rust.RealizesFn +@1081 := @1076 (@1077 @1012 @127 @4) +@1082 := LexLeanPreservation.Rust.RCI +@1084 := @1082 #15 +@1085 := LexLeanPreservation.Rust.fnIdent +@1086 := @1085 @1066 +@1093 := (hne : @1072) -> @1075 (fun (ro : @1074) => @1081 (@1084 @1086 @1058 @4)) +@1108 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {f : @27} -> + {fn : @851} -> + {args : @111} -> + {env : @1010} -> + {F : @984} -> + {o : @986} -> + (hB : @1018) -> + (hfn : @1034) -> (hwt : @1042) -> (hbind : @1054) -> (hF : @1064) -> (hA : @1070) -> @1093 +@1110 := LexLeanPreservation.Rust.compose @0 +@1111 := @1011 @0 +@1116 := (n : @27) -> @1111 @127 @121 @4 @113 +@1117 := @1027 @853 +@1120 := @1020 (@1117 @113) @1033 +@1124 := @93 @1012 @127 @115 @1041 +@1125 := @1065 @0 +@1128 := @1125 @1035 @127 @115 +@1142 := {c : @25} -> + {A : @26} -> + {f : @27} -> + {fn : @851} -> + {args : @111} -> + {env : @1010} -> + {F : @984} -> + {o : @986} -> + (hB : @1116) -> + (hfn : @1120) -> (hwt : @1124) -> (hbind : @1054) -> (hF : @1064) -> (hA : @1128) -> @1093 +@1143 := @1110 @1 +@1144 := @1111 @1 +@1148 := (n : @27) -> @1144 @121 @4 @113 +@1151 := @101 @127 @115 @1041 +@1152 := @1057 @1 +@1155 := @1056 (@1152 @1012) @1063 +@1156 := @1082 @1 +@1166 := (hbind : @1054) -> + (hF : @1155) -> + (hA : @1128) -> (hne : @1072) -> @1075 (fun (ro : @1074) => @1081 (@1156 @1086 @1058 @4)) +@1176 := {A : @26} -> + {f : @27} -> + {fn : @851} -> + {args : @111} -> + {env : @1010} -> + {F : @984} -> {o : @986} -> (hB : @1148) -> (hfn : @1120) -> (hwt : @1151) -> @1166 +@1177 := @1143 @2 +@1179 := @1144 @2 @4 +@1181 := (n : @27) -> @1179 @113 +@1182 := @107 @115 +@1183 := @1182 @1041 +@1192 := {f : @27} -> + {fn : @851} -> + {args : @111} -> + {env : @1010} -> + {F : @984} -> {o : @986} -> (hB : @1181) -> (hfn : @1120) -> (hwt : @1183) -> @1166 +@1193 := @1177 @9 +@1195 := (n : @27) -> @1179 @9 +@1196 := @1117 @9 +@1197 := @1020 @1196 +@1198 := @1197 @1033 +@1199 := @1152 @9 +@1200 := @1056 @1199 +@1201 := @1200 @1063 +@1202 := @1125 @9 +@1204 := @1202 @127 @115 +@1206 := @1156 (@1085 @9) +@1214 := (hF : @1201) -> + (hA : @1204) -> (hne : @1072) -> @1075 (fun (ro : @1074) => @1081 (@1206 @1058 @4)) +@1223 := {fn : @851} -> + {args : @111} -> + {env : @1010} -> + {F : @984} -> + {o : @986} -> (hB : @1195) -> (hfn : @1198) -> (hwt : @1183) -> (hbind : @1054) -> @1214 +@1224 := @1193 @869 +@1226 := @1197 (@1032 @869) +@1227 := @1040 @869 +@1228 := @1182 @1227 +@1230 := @1045 (@1046 @869) +@1242 := {args : @111} -> + {env : @1010} -> + {F : @984} -> + {o : @986} -> + (hB : @1195) -> (hfn : @1226) -> (hwt : @1228) -> (hbind : @1044 (@1230 @113 @844) @1053) -> @1214 +@1243 := @1224 @833 +@1245 := @928 (@879 @71) +@1247 := @107 @1245 @1227 +@1249 := @72 (@21 @127) +@1251 := @1249 (@928 @71) +@1255 := @1044 (@1230 @1251 @844) @1053 +@1257 := @72 (@21 @1035) +@1259 := @72 (@21 @1012) +@1261 := @1257 (@1259 @71) +@1263 := @1202 @1261 @115 +@1265 := @72 (@21 @1066) +@1268 := @72 (@21 #12) +@1285 := {env : @1010} -> + {F : @984} -> + {o : @986} -> + (hB : @1195) -> + (hfn : @1226) -> + (hwt : @1247) -> + (hbind : @1255) -> + (hF : @1201) -> + (hA : @1263) -> (hne : @1072) -> @1075 (fun (ro : @1074) => @1081 (@1206 (@1265 (@1268 @71)) @4)) +@1286 := @1243 @849 +@1288 := @879 (@893 @71) +@1290 := @107 @1288 @1227 +@1301 := @1044 (@1230 @1245 @844) (@1052 (@845 (@840 @878) (@845 (@842 @927) @844))) +@1303 := @1259 (@1249 @71) +@1305 := @1202 @1303 @115 +@1307 := @72 (@21 @1058) +@1323 := {F : @984} -> + {o : @986} -> + (hB : @1195) -> + (hfn : @1226) -> + (hwt : @1290) -> + (hbind : @1301) -> + (hF : @1201) -> + (hA : @1305) -> (hne : @1072) -> @1075 (fun (ro : @1074) => @1081 (@1206 (@1268 (@1307 @71)) @4)) +@1324 := @1286 @850 +@1325 := @947 @1227 +@1336 := @1044 (@1230 @1288 @844) (@1052 (@845 (@840 @892) (@845 (@842 @878) @844))) +@1338 := @1200 (@1062 @850) +@1340 := @1202 @1251 @115 +@1341 := @1077 @850 +@1359 := {o : @986} -> + (hB : @1195) -> + (hfn : @1226) -> + (hwt : @1325) -> + (hbind : @1336) -> + (hF : @1338) -> + (hA : @1340) -> + (hne : @1072) -> @1075 (fun (ro : @1074) => @1076 (@1341 @127 @4) (@1206 (@1307 (@1257 @71)) @4)) +@1360 := @1324 @968 +@1361 := @954 @1227 +@1372 := @1044 (@1230 @946 @844) (@1052 (@845 (@840 @875) (@845 (@842 @892) @844))) +@1373 := @1202 @1245 +@1375 := @966 @121 @113 +@1376 := @1373 @1375 +@1378 := @966 @127 @121 +@1397 := (hB : @1195) -> + (hfn : @1226) -> + (hwt : @1361) -> + (hbind : @1372) -> + (hF : @1338) -> + (hA : @1376) -> + (hne : @987 @1378 @992) -> + @1075 (fun (ro : @1074) => @1076 (@1341 (@966 @1035 @1012) @4) (@1206 @1261 @4)) +@1398 := @1360 @873 +@1399 := @960 @1227 +@1410 := @1044 (@1230 @953 @844) (@1052 (@845 (@840 @889) (@845 (@842 @875) @844))) +@1411 := @1202 @1288 +@1413 := @966 @113 @115 +@1432 := (hfn : @1226) -> + (hwt : @1399) -> + (hbind : @1410) -> + (hF : @1338) -> + (hA : @1411 @1413) -> + (hne : @987 @1375 @992) -> + @1075 (fun (ro : @1074) => @1076 (@1341 (@966 @1012 @127) @4) (@1206 @1303 @4)) +@1435 := @1398 (@428 @1019 @1196) +@1436 := @964 @1227 +@1447 := @1044 (@1230 @959 @844) (@1052 (@845 (@840 @822) (@845 (@842 @889) @844))) +@1448 := @1202 @946 +@1450 := @966 @115 @117 +@1466 := (hwt : @1436) -> + (hbind : @1447) -> + (hF : @1338) -> + (hA : @1448 @1450) -> + (hne : @987 @1413 @992) -> @1075 (fun (ro : @1074) => @1076 (@1341 @1378 @4) (@1206 @1251 @4)) +@1467 := @1435 @963 +@1469 := @1230 @833 @844 +@1472 := @1044 @1469 (@1052 @849) +@1473 := @1202 @953 +@1475 := @966 @117 @28 +@1490 := (hbind : @1472) -> + (hF : @1338) -> + (hA : @1473 @1475) -> + (hne : @987 @1450 @992) -> @1075 (fun (ro : @1074) => @1076 (@1341 @1375 @4) (@1206 @1245 @4)) +@1493 := @1467 (@428 @1043 @1469) +@1494 := @1202 @959 +@1496 := @966 @28 @30 +@1510 := (hF : @1338) -> + (hA : @1494 @1496) -> + (hne : @987 @1475 @992) -> @1075 (fun (ro : @1074) => @1076 (@1341 @1413 @4) (@1206 @1288 @4)) +@1513 := @1493 (@428 @1055 @1199) +@1527 := (hA : @1202 @833 @968) -> + (hne : @987 @1496 @992) -> @1075 (fun (ro : @1074) => @1076 (@1341 @1450 @4) (@1206 @946 @4)) +@1528 := @1513 @983 +@1539 := (hne : @987 @968 @992) -> + @1075 (fun (ro : @1074) => @1076 (@1341 @1475 @4) (@1206 @953 @4)) +@1540 := @1528 @1005 +@1546 := @1076 (@1341 @1496 @4) (@1206 @959 @4) +@1548 := @1075 (fun (ro : @1074) => @1546) +@1550 := @1075 (fun (__e_ro : @1074) => @1546) +@1555 := LexLeanPreservation.Rust.RepresentableL (@830 (@72 @34 @71)) +@1556 := (__e_hrep : @1555) -> @1550 +@1557 := fun (__e_hrep : @1555) => @1540 +@1558 := (b : @27) -> @1556 +@1559 := fun (b : @27) => @1557 +@1560 := (a : @27) -> @1558 +@1561 := fun (a : @27) => @1559 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustStd.lean deleted file mode 100644 index 4011de8bb..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustStd.lean +++ /dev/null @@ -1,25 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd - -theorem __wt_0 : ∀ (__s : (Coverage.Types.Point)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_0 __s) (.adt 0) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).x) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).y) _root_.LexLeanPreservation.Rust.wtl_nil)) - -theorem __wt_1 : ∀ (__s : (Coverage.Types.Box Nat)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_1 __s) (.adt 1) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).content) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).count) _root_.LexLeanPreservation.Rust.wtl_nil)) - -theorem __wt_2 : ∀ (__s : (Coverage.Types.Weights)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_2 __s) (.adt 2) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).base) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).scale) _root_.LexLeanPreservation.Rust.wtl_nil)) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Nat) (b : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustStd.lex.tex new file mode 100644 index 000000000..a38cf47c5 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustStd.lex.tex @@ -0,0 +1,776 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_1 : @449 := @632 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_2 : @640 := @821 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.root : @1560 := @1561 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.flags +@3 := Coverage.Types.Point +@4 := #0 +@6 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_0 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@16 := (__s : @3) -> @13 @6 @10 +@17 := Coverage.Types.Point.x +@18 := @17 @4 +@19 := Coverage.Types.Point.y +@20 := @19 @4 +@21 := LexLeanTarget.TargetSyntax.Value.nat +@22 := @21 @18 +@23 := LexLeanTarget.TargetSyntax.Ty.nat +@24 := LexLeanTarget.TargetSyntax.Program +@25 := LexLeanPreservation.Rust.RCrate +@26 := LexLeanPreservation.Rust.Flags +@27 := Nat +@28 := #3 +@29 := @7 @28 +@30 := #2 +@31 := @29 @30 +@32 := #1 +@33 := @31 @32 +@34 := @21 @4 +@40 := {p : @24} -> {c : @25} -> {A : @26} -> (n : @27) -> @33 @34 @23 +@42 := LexLeanPreservation.Rust.wt_nat @0 +@49 := {c : @25} -> {A : @26} -> (n : @27) -> @11 @30 @32 @34 @23 +@50 := @42 @1 +@55 := {A : @26} -> (n : @27) -> @12 @32 @34 @23 +@56 := @50 @2 +@59 := (n : @27) -> @13 @34 @23 +@60 := @56 @18 +@62 := @13 @22 @23 +@63 := @21 @20 +@64 := @56 @20 +@66 := @13 @63 @23 +@67 := LexLeanTarget.TargetSyntax.Value +@68 := LexLeanTarget.TargetSyntax.Ty +@69 := List.nil.{0} +@70 := List.cons.{0} +@71 := @69 @67 +@72 := @70 @67 +@74 := @72 @63 @71 +@76 := @72 @22 @74 +@77 := @69 @68 +@78 := @70 @68 +@79 := @78 @23 +@80 := @79 @77 +@81 := @79 @80 +@82 := LexLeanPreservation.Rust.WTL +@90 := {p : @24} -> {c : @25} -> {A : @26} -> @82 @30 @32 @4 @71 @77 +@92 := LexLeanPreservation.Rust.wtl_nil @0 +@93 := @82 @0 +@99 := {c : @25} -> {A : @26} -> @93 @32 @4 @71 @77 +@100 := @92 @1 +@101 := @93 @1 +@105 := {A : @26} -> @101 @4 @71 @77 +@106 := @100 @2 +@107 := @101 @2 +@108 := @107 @71 +@109 := @108 @77 +@110 := List.{0} +@111 := @110 @67 +@112 := @110 @68 +@113 := #6 +@114 := @7 @113 +@115 := #5 +@116 := @114 @115 +@117 := #4 +@120 := @116 @117 @28 @30 +@121 := #7 +@126 := @82 @121 @113 @115 @30 @32 +@127 := #8 +@130 := @82 @127 @121 @113 +@132 := @72 @115 @28 +@133 := @130 @132 +@135 := @78 @117 @30 +@145 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {v : @67} -> {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @120) -> (hs : @126) -> @133 @135 +@147 := LexLeanPreservation.Rust.wtl_cons @0 +@151 := @11 @115 @117 @28 @30 +@155 := @93 @113 @115 @30 @32 +@167 := {c : @25} -> + {A : @26} -> + {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @151) -> (hs : @155) -> @93 @121 @113 @132 @135 +@168 := @147 @1 +@171 := @12 @117 @28 @30 +@174 := @101 @115 @30 @32 +@184 := {A : @26} -> + {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @171) -> (hs : @174) -> @101 @113 @132 @135 +@185 := @168 @2 +@187 := @13 @28 @30 +@189 := @107 @30 @32 +@197 := {v : @67} -> + {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @187) -> (hs : @189) -> @107 @132 @135 +@198 := @185 @63 +@200 := @21 (@19 @28) +@213 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @200 @30) -> (hs : @189) -> @107 (@72 (@21 (@19 @115)) @28) @135 +@214 := @198 @23 +@216 := @21 (@19 @30) +@218 := @13 @216 @23 +@223 := @107 (@72 (@21 (@19 @117)) @28) +@224 := @79 @30 +@229 := {vs : @111} -> {ts : @112} -> (h : @218) -> (hs : @189) -> @223 @224 +@230 := @214 @71 +@232 := @21 (@19 @32) +@234 := @13 @232 @23 +@235 := @108 @32 +@237 := @72 @200 @71 +@242 := {ts : @112} -> (h : @234) -> (hs : @235) -> @107 @237 @224 +@243 := @230 @77 +@245 := @72 @216 @71 +@246 := @107 @245 +@249 := (h : @66) -> (hs : @109) -> @246 @80 +@250 := @243 @64 +@252 := @72 @232 @71 +@254 := @107 @252 @80 +@255 := (hs : @109) -> @254 +@256 := @250 @106 +@258 := @107 @74 @80 +@259 := @185 @22 +@261 := @21 (@17 @28) +@274 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @261 @30) -> (hs : @189) -> @107 (@72 (@21 (@17 @115)) @28) @135 +@275 := @259 @23 +@277 := @21 (@17 @30) +@289 := {vs : @111} -> + {ts : @112} -> (h : @13 @277 @23) -> (hs : @189) -> @107 (@72 (@21 (@17 @117)) @28) @224 +@290 := @275 @74 +@292 := @21 (@17 @32) +@294 := @13 @292 @23 +@295 := @246 @32 +@297 := @72 @261 @237 +@302 := {ts : @112} -> (h : @294) -> (hs : @295) -> @107 @297 @224 +@303 := @290 @80 +@305 := @72 @277 @245 +@306 := @107 @305 +@309 := (h : @62) -> (hs : @254) -> @306 @81 +@310 := @303 @60 +@312 := @72 @292 @252 +@314 := @107 @312 @81 +@315 := (hs : @258) -> @314 +@316 := @310 @256 +@318 := @107 @76 @81 +@319 := Eq.{1} +@320 := Option.{0} +@321 := @320 @112 +@322 := @319 @321 +@323 := LexLeanPreservation.Rust.adtFields +@327 := @322 (@323 @113 @28 @30) +@328 := Option.some.{0} +@329 := @328 @112 +@330 := @329 @4 +@331 := @327 @330 +@334 := @7 @127 @121 @113 +@335 := LexLeanTarget.TargetSyntax.Value.adt +@337 := @335 @117 @28 +@338 := @334 @337 +@339 := @8 @115 +@349 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {i : @27} -> {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @331) -> (hf : @126) -> @338 @339 +@351 := LexLeanPreservation.Rust.wt_adt @0 +@352 := @323 @0 +@356 := @322 (@352 @28 @30) @330 +@368 := {c : @25} -> + {A : @26} -> + {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @155) -> @11 @121 @113 @337 @339 +@369 := @351 @1 +@379 := {A : @26} -> + {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @174) -> @12 @113 @337 @339 +@380 := @369 @2 +@381 := @13 @337 +@388 := {i : @27} -> + {k : @27} -> {fs : @111} -> {tys : @112} -> (h : @356) -> (hf : @189) -> @381 @339 +@389 := @380 @9 +@390 := @352 @9 +@399 := {k : @27} -> + {fs : @111} -> {tys : @112} -> (h : @322 (@390 @30) @330) -> (hf : @189) -> @381 @10 +@400 := @389 @9 +@401 := @390 @9 +@402 := @322 @401 +@403 := @402 @330 +@404 := @335 @9 +@406 := @13 (@404 @28) +@411 := {fs : @111} -> {tys : @112} -> (h : @403) -> (hf : @189) -> @406 @10 +@412 := @400 @76 +@419 := {tys : @112} -> (h : @403) -> (hf : @306 @32) -> @13 (@404 @297) @10 +@420 := @412 @81 +@421 := @329 @81 +@427 := (h : @402 @421) -> (hf : @314) -> @13 (@404 @305) @10 +@428 := Eq.refl.{1} +@429 := @428 @321 +@431 := @420 (@429 @401) +@435 := (hf : @318) -> @13 (@404 @312) @10 +@436 := @431 @316 +@439 := @13 (@404 @76) @10 +@440 := fun (__s : @3) => @436 +@442 := Coverage.Types.Box @27 +@444 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_1 @4 +@445 := 1 +@446 := @8 @445 +@449 := (__s : @442) -> @13 @444 @446 +@451 := Coverage.Types.Box.content @27 +@452 := @451 @4 +@454 := Coverage.Types.Box.count @27 +@455 := @454 @4 +@456 := @21 @452 +@457 := @56 @452 +@459 := @13 @456 @23 +@460 := @21 @455 +@461 := @56 @455 +@463 := @13 @460 @23 +@465 := @72 @460 @71 +@467 := @72 @456 @465 +@468 := @185 @460 +@470 := @21 (@454 @28) +@483 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @470 @30) -> (hs : @189) -> @107 (@72 (@21 (@454 @115)) @28) @135 +@484 := @468 @23 +@486 := @21 (@454 @30) +@498 := {vs : @111} -> + {ts : @112} -> (h : @13 @486 @23) -> (hs : @189) -> @107 (@72 (@21 (@454 @117)) @28) @224 +@499 := @484 @71 +@501 := @21 (@454 @32) +@503 := @13 @501 @23 +@505 := @72 @470 @71 +@510 := {ts : @112} -> (h : @503) -> (hs : @235) -> @107 @505 @224 +@511 := @499 @77 +@513 := @72 @486 @71 +@514 := @107 @513 +@517 := (h : @463) -> (hs : @109) -> @514 @80 +@518 := @511 @461 +@520 := @72 @501 @71 +@522 := @107 @520 @80 +@523 := (hs : @109) -> @522 +@524 := @518 @106 +@526 := @107 @465 @80 +@527 := @185 @456 +@529 := @21 (@451 @28) +@542 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @529 @30) -> (hs : @189) -> @107 (@72 (@21 (@451 @115)) @28) @135 +@543 := @527 @23 +@545 := @21 (@451 @30) +@557 := {vs : @111} -> + {ts : @112} -> (h : @13 @545 @23) -> (hs : @189) -> @107 (@72 (@21 (@451 @117)) @28) @224 +@558 := @543 @465 +@560 := @21 (@451 @32) +@562 := @13 @560 @23 +@563 := @514 @32 +@565 := @72 @529 @505 +@570 := {ts : @112} -> (h : @562) -> (hs : @563) -> @107 @565 @224 +@571 := @558 @80 +@573 := @72 @545 @513 +@574 := @107 @573 +@577 := (h : @459) -> (hs : @522) -> @574 @81 +@578 := @571 @457 +@580 := @72 @560 @520 +@582 := @107 @580 @81 +@583 := (hs : @526) -> @582 +@584 := @578 @524 +@586 := @107 @467 @81 +@587 := @380 @445 +@588 := @352 @445 +@597 := {k : @27} -> + {fs : @111} -> {tys : @112} -> (h : @322 (@588 @30) @330) -> (hf : @189) -> @381 @446 +@598 := @587 @9 +@599 := @588 @9 +@600 := @322 @599 +@601 := @600 @330 +@606 := {fs : @111} -> {tys : @112} -> (h : @601) -> (hf : @189) -> @406 @446 +@607 := @598 @467 +@614 := {tys : @112} -> (h : @601) -> (hf : @574 @32) -> @13 (@404 @565) @446 +@615 := @607 @81 +@621 := (h : @600 @421) -> (hf : @582) -> @13 (@404 @573) @446 +@623 := @615 (@429 @599) +@627 := (hf : @586) -> @13 (@404 @580) @446 +@628 := @623 @584 +@631 := @13 (@404 @467) @446 +@632 := fun (__s : @442) => @628 +@633 := Coverage.Types.Weights +@635 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__enc_2 @4 +@636 := 2 +@637 := @8 @636 +@640 := (__s : @633) -> @13 @635 @637 +@641 := Coverage.Types.Weights.base +@642 := @641 @4 +@643 := Coverage.Types.Weights.scale +@644 := @643 @4 +@645 := @21 @642 +@646 := @56 @642 +@648 := @13 @645 @23 +@649 := @21 @644 +@650 := @56 @644 +@652 := @13 @649 @23 +@654 := @72 @649 @71 +@656 := @72 @645 @654 +@657 := @185 @649 +@659 := @21 (@643 @28) +@672 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @659 @30) -> (hs : @189) -> @107 (@72 (@21 (@643 @115)) @28) @135 +@673 := @657 @23 +@675 := @21 (@643 @30) +@687 := {vs : @111} -> + {ts : @112} -> (h : @13 @675 @23) -> (hs : @189) -> @107 (@72 (@21 (@643 @117)) @28) @224 +@688 := @673 @71 +@690 := @21 (@643 @32) +@692 := @13 @690 @23 +@694 := @72 @659 @71 +@699 := {ts : @112} -> (h : @692) -> (hs : @235) -> @107 @694 @224 +@700 := @688 @77 +@702 := @72 @675 @71 +@703 := @107 @702 +@706 := (h : @652) -> (hs : @109) -> @703 @80 +@707 := @700 @650 +@709 := @72 @690 @71 +@711 := @107 @709 @80 +@712 := (hs : @109) -> @711 +@713 := @707 @106 +@715 := @107 @654 @80 +@716 := @185 @645 +@718 := @21 (@641 @28) +@731 := {t : @68} -> + {vs : @111} -> + {ts : @112} -> (h : @13 @718 @30) -> (hs : @189) -> @107 (@72 (@21 (@641 @115)) @28) @135 +@732 := @716 @23 +@734 := @21 (@641 @30) +@746 := {vs : @111} -> + {ts : @112} -> (h : @13 @734 @23) -> (hs : @189) -> @107 (@72 (@21 (@641 @117)) @28) @224 +@747 := @732 @654 +@749 := @21 (@641 @32) +@751 := @13 @749 @23 +@752 := @703 @32 +@754 := @72 @718 @694 +@759 := {ts : @112} -> (h : @751) -> (hs : @752) -> @107 @754 @224 +@760 := @747 @80 +@762 := @72 @734 @702 +@763 := @107 @762 +@766 := (h : @648) -> (hs : @711) -> @763 @81 +@767 := @760 @646 +@769 := @72 @749 @709 +@771 := @107 @769 @81 +@772 := (hs : @715) -> @771 +@773 := @767 @713 +@775 := @107 @656 @81 +@776 := @380 @636 +@777 := @352 @636 +@786 := {k : @27} -> + {fs : @111} -> {tys : @112} -> (h : @322 (@777 @30) @330) -> (hf : @189) -> @381 @637 +@787 := @776 @9 +@788 := @777 @9 +@789 := @322 @788 +@790 := @789 @330 +@795 := {fs : @111} -> {tys : @112} -> (h : @790) -> (hf : @189) -> @406 @637 +@796 := @787 @656 +@803 := {tys : @112} -> (h : @790) -> (hf : @763 @32) -> @13 (@404 @754) @637 +@804 := @796 @81 +@810 := (h : @789 @421) -> (hf : @771) -> @13 (@404 @762) @637 +@812 := @804 (@429 @788) +@816 := (hf : @775) -> @13 (@404 @769) @637 +@817 := @812 @773 +@820 := @13 (@404 @656) @637 +@821 := fun (__s : @633) => @817 +@822 := @21 @30 +@823 := @56 @30 +@825 := @13 @822 @23 +@826 := @21 @32 +@827 := @56 @32 +@829 := @13 @826 @23 +@830 := @72 @826 +@831 := @830 @71 +@832 := @72 @822 +@833 := @832 @831 +@836 := Prod.{0, 0} @27 @67 +@839 := Prod.mk.{0, 0} @27 @67 +@840 := @839 @445 +@841 := @840 @826 +@842 := @839 @9 +@843 := @842 @822 +@844 := @69 @836 +@845 := @70 @836 +@847 := @845 @843 @844 +@849 := @845 @841 @847 +@850 := Bool.true +@851 := LexLeanTarget.TargetSyntax.Function +@852 := LexLeanTarget.TargetSyntax.Program.functions +@853 := @852 @0 +@854 := @69 @27 +@855 := LexLeanTarget.TargetSyntax.Ty.unit +@856 := LexLeanTarget.TargetSyntax.Value.unit +@859 := LexLeanTarget.TargetSyntax.Expr.value @855 @856 +@864 := LexLeanTarget.TargetSyntax.Function.mk @854 @77 @855 @859 +@869 := List.getD.{0} @851 @853 @9 @864 +@873 := fun (__e_n : @27) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.root @4 @9 +@874 := @185 @826 +@875 := @21 @117 +@876 := @13 @875 +@877 := @876 @30 +@878 := @21 @113 +@879 := @72 @878 +@881 := @107 (@879 @28) +@887 := {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @877) -> (hs : @189) -> @881 @135 +@888 := @874 @23 +@889 := @21 @28 +@891 := @13 @889 @23 +@892 := @21 @115 +@893 := @72 @892 +@900 := {vs : @111} -> {ts : @112} -> (h : @891) -> (hs : @189) -> @107 (@893 @28) @224 +@901 := @888 @71 +@902 := @72 @875 +@903 := @902 @71 +@908 := {ts : @112} -> (h : @825) -> (hs : @235) -> @107 @903 @224 +@909 := @901 @77 +@910 := @72 @889 +@911 := @910 @71 +@912 := @107 @911 +@915 := (h : @829) -> (hs : @109) -> @912 @80 +@916 := @909 @827 +@917 := @832 @71 +@919 := @107 @917 @80 +@920 := (hs : @109) -> @919 +@921 := @916 @106 +@923 := @107 @831 @80 +@924 := @185 @822 +@926 := @13 @892 @30 +@927 := @21 @121 +@928 := @72 @927 +@936 := {t : @68} -> {vs : @111} -> {ts : @112} -> (h : @926) -> (hs : @189) -> @107 (@928 @28) @135 +@937 := @924 @23 +@943 := {vs : @111} -> {ts : @112} -> (h : @876 @23) -> (hs : @189) -> @881 @224 +@944 := @937 @831 +@945 := @912 @32 +@946 := @893 @903 +@947 := @107 @946 +@951 := {ts : @112} -> (h : @891) -> (hs : @945) -> @947 @224 +@952 := @944 @80 +@953 := @902 @911 +@954 := @107 @953 +@957 := (h : @825) -> (hs : @919) -> @954 @81 +@958 := @952 @823 +@959 := @910 @917 +@960 := @107 @959 +@962 := (hs : @923) -> @960 @81 +@963 := @958 @921 +@964 := @107 @833 +@965 := @964 @81 +@966 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.denote +@968 := @966 @30 @32 +@969 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.__fits_0 +@971 := @969 @30 @32 +@974 := Coverage.Main.records @30 @32 +@980 := LexLeanPreservation.encPair @27 @27 @21 @21 @974 +@983 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.root @30 @32 +@984 := Bool +@985 := Ne.{1} +@986 := LexLeanPreservation.Obs +@987 := @985 @986 +@988 := LexLeanPreservation.Rel +@991 := @987 (@988 @32 @4) +@992 := LexLeanPreservation.Obs.stuck +@995 := (f : @984) -> (v : @67) -> @991 @992 +@997 := LexLeanPreservation.Rust.rel_ne_stuck @971 +@1004 := (v : @67) -> @987 (@988 (@969 @28 @30) @4) @992 +@1005 := @997 @980 +@1009 := @987 (@988 @971 @980) @992 +@1010 := @110 @836 +@1011 := LexLeanPreservation.Rust.FunSem +@1012 := #9 +@1018 := (n : @27) -> @1011 @1012 @127 @121 @4 @113 +@1019 := @320 @851 +@1020 := @319 @1019 +@1027 := LexLeanRuntime.index (@110 @851) @851 (LexLeanRuntime.instIndexableList @851) +@1031 := @1020 (@1027 (@852 @1012) @113) +@1032 := @328 @851 +@1033 := @1032 @115 +@1034 := @1031 @1033 +@1035 := #10 +@1039 := @82 @1035 @1012 @127 @115 +@1040 := LexLeanTarget.TargetSyntax.Function.types +@1041 := @1040 @113 +@1042 := @1039 @1041 +@1043 := @320 @1010 +@1044 := @319 @1043 +@1045 := LexLeanTarget.TargetSemantics.bindAll +@1046 := LexLeanTarget.TargetSyntax.Function.parameters +@1051 := @1044 (@1045 (@1046 @121) @113 @844) +@1052 := @328 @1010 +@1053 := @1052 @115 +@1054 := @1051 @1053 +@1055 := @320 @984 +@1056 := @319 @1055 +@1057 := LexLeanPreservation.Rust.fnFallible +@1058 := #11 +@1061 := @1056 (@1057 @1058 @1012) +@1062 := @328 @984 +@1063 := @1062 @115 +@1064 := @1061 @1063 +@1065 := LexLeanPreservation.RunConv +@1066 := #13 +@1070 := @1065 @1066 @1035 @127 @115 +@1072 := @987 @113 @992 +@1073 := Exists.{1} +@1074 := LexLeanPreservation.Rust.ROut +@1075 := @1073 @1074 +@1076 := And +@1077 := LexLeanPreservation.Rust.RealizesFn +@1081 := @1076 (@1077 @1012 @127 @4) +@1082 := LexLeanPreservation.Rust.RCI +@1084 := @1082 #15 +@1085 := LexLeanPreservation.Rust.fnIdent +@1086 := @1085 @1066 +@1093 := (hne : @1072) -> @1075 (fun (ro : @1074) => @1081 (@1084 @1086 @1058 @4)) +@1108 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {f : @27} -> + {fn : @851} -> + {args : @111} -> + {env : @1010} -> + {F : @984} -> + {o : @986} -> + (hB : @1018) -> + (hfn : @1034) -> (hwt : @1042) -> (hbind : @1054) -> (hF : @1064) -> (hA : @1070) -> @1093 +@1110 := LexLeanPreservation.Rust.compose @0 +@1111 := @1011 @0 +@1116 := (n : @27) -> @1111 @127 @121 @4 @113 +@1117 := @1027 @853 +@1120 := @1020 (@1117 @113) @1033 +@1124 := @93 @1012 @127 @115 @1041 +@1125 := @1065 @0 +@1128 := @1125 @1035 @127 @115 +@1142 := {c : @25} -> + {A : @26} -> + {f : @27} -> + {fn : @851} -> + {args : @111} -> + {env : @1010} -> + {F : @984} -> + {o : @986} -> + (hB : @1116) -> + (hfn : @1120) -> (hwt : @1124) -> (hbind : @1054) -> (hF : @1064) -> (hA : @1128) -> @1093 +@1143 := @1110 @1 +@1144 := @1111 @1 +@1148 := (n : @27) -> @1144 @121 @4 @113 +@1151 := @101 @127 @115 @1041 +@1152 := @1057 @1 +@1155 := @1056 (@1152 @1012) @1063 +@1156 := @1082 @1 +@1166 := (hbind : @1054) -> + (hF : @1155) -> + (hA : @1128) -> (hne : @1072) -> @1075 (fun (ro : @1074) => @1081 (@1156 @1086 @1058 @4)) +@1176 := {A : @26} -> + {f : @27} -> + {fn : @851} -> + {args : @111} -> + {env : @1010} -> + {F : @984} -> {o : @986} -> (hB : @1148) -> (hfn : @1120) -> (hwt : @1151) -> @1166 +@1177 := @1143 @2 +@1179 := @1144 @2 @4 +@1181 := (n : @27) -> @1179 @113 +@1182 := @107 @115 +@1183 := @1182 @1041 +@1192 := {f : @27} -> + {fn : @851} -> + {args : @111} -> + {env : @1010} -> + {F : @984} -> {o : @986} -> (hB : @1181) -> (hfn : @1120) -> (hwt : @1183) -> @1166 +@1193 := @1177 @9 +@1195 := (n : @27) -> @1179 @9 +@1196 := @1117 @9 +@1197 := @1020 @1196 +@1198 := @1197 @1033 +@1199 := @1152 @9 +@1200 := @1056 @1199 +@1201 := @1200 @1063 +@1202 := @1125 @9 +@1204 := @1202 @127 @115 +@1206 := @1156 (@1085 @9) +@1214 := (hF : @1201) -> + (hA : @1204) -> (hne : @1072) -> @1075 (fun (ro : @1074) => @1081 (@1206 @1058 @4)) +@1223 := {fn : @851} -> + {args : @111} -> + {env : @1010} -> + {F : @984} -> + {o : @986} -> (hB : @1195) -> (hfn : @1198) -> (hwt : @1183) -> (hbind : @1054) -> @1214 +@1224 := @1193 @869 +@1226 := @1197 (@1032 @869) +@1227 := @1040 @869 +@1228 := @1182 @1227 +@1230 := @1045 (@1046 @869) +@1242 := {args : @111} -> + {env : @1010} -> + {F : @984} -> + {o : @986} -> + (hB : @1195) -> (hfn : @1226) -> (hwt : @1228) -> (hbind : @1044 (@1230 @113 @844) @1053) -> @1214 +@1243 := @1224 @833 +@1245 := @928 (@879 @71) +@1247 := @107 @1245 @1227 +@1249 := @72 (@21 @127) +@1251 := @1249 (@928 @71) +@1255 := @1044 (@1230 @1251 @844) @1053 +@1257 := @72 (@21 @1035) +@1259 := @72 (@21 @1012) +@1261 := @1257 (@1259 @71) +@1263 := @1202 @1261 @115 +@1265 := @72 (@21 @1066) +@1268 := @72 (@21 #12) +@1285 := {env : @1010} -> + {F : @984} -> + {o : @986} -> + (hB : @1195) -> + (hfn : @1226) -> + (hwt : @1247) -> + (hbind : @1255) -> + (hF : @1201) -> + (hA : @1263) -> (hne : @1072) -> @1075 (fun (ro : @1074) => @1081 (@1206 (@1265 (@1268 @71)) @4)) +@1286 := @1243 @849 +@1288 := @879 (@893 @71) +@1290 := @107 @1288 @1227 +@1301 := @1044 (@1230 @1245 @844) (@1052 (@845 (@840 @878) (@845 (@842 @927) @844))) +@1303 := @1259 (@1249 @71) +@1305 := @1202 @1303 @115 +@1307 := @72 (@21 @1058) +@1323 := {F : @984} -> + {o : @986} -> + (hB : @1195) -> + (hfn : @1226) -> + (hwt : @1290) -> + (hbind : @1301) -> + (hF : @1201) -> + (hA : @1305) -> (hne : @1072) -> @1075 (fun (ro : @1074) => @1081 (@1206 (@1268 (@1307 @71)) @4)) +@1324 := @1286 @850 +@1325 := @947 @1227 +@1336 := @1044 (@1230 @1288 @844) (@1052 (@845 (@840 @892) (@845 (@842 @878) @844))) +@1338 := @1200 (@1062 @850) +@1340 := @1202 @1251 @115 +@1341 := @1077 @850 +@1359 := {o : @986} -> + (hB : @1195) -> + (hfn : @1226) -> + (hwt : @1325) -> + (hbind : @1336) -> + (hF : @1338) -> + (hA : @1340) -> + (hne : @1072) -> @1075 (fun (ro : @1074) => @1076 (@1341 @127 @4) (@1206 (@1307 (@1257 @71)) @4)) +@1360 := @1324 @968 +@1361 := @954 @1227 +@1372 := @1044 (@1230 @946 @844) (@1052 (@845 (@840 @875) (@845 (@842 @892) @844))) +@1373 := @1202 @1245 +@1375 := @966 @121 @113 +@1376 := @1373 @1375 +@1378 := @966 @127 @121 +@1397 := (hB : @1195) -> + (hfn : @1226) -> + (hwt : @1361) -> + (hbind : @1372) -> + (hF : @1338) -> + (hA : @1376) -> + (hne : @987 @1378 @992) -> + @1075 (fun (ro : @1074) => @1076 (@1341 (@966 @1035 @1012) @4) (@1206 @1261 @4)) +@1398 := @1360 @873 +@1399 := @960 @1227 +@1410 := @1044 (@1230 @953 @844) (@1052 (@845 (@840 @889) (@845 (@842 @875) @844))) +@1411 := @1202 @1288 +@1413 := @966 @113 @115 +@1432 := (hfn : @1226) -> + (hwt : @1399) -> + (hbind : @1410) -> + (hF : @1338) -> + (hA : @1411 @1413) -> + (hne : @987 @1375 @992) -> + @1075 (fun (ro : @1074) => @1076 (@1341 (@966 @1012 @127) @4) (@1206 @1303 @4)) +@1435 := @1398 (@428 @1019 @1196) +@1436 := @964 @1227 +@1447 := @1044 (@1230 @959 @844) (@1052 (@845 (@840 @822) (@845 (@842 @889) @844))) +@1448 := @1202 @946 +@1450 := @966 @115 @117 +@1466 := (hwt : @1436) -> + (hbind : @1447) -> + (hF : @1338) -> + (hA : @1448 @1450) -> + (hne : @987 @1413 @992) -> @1075 (fun (ro : @1074) => @1076 (@1341 @1378 @4) (@1206 @1251 @4)) +@1467 := @1435 @963 +@1469 := @1230 @833 @844 +@1472 := @1044 @1469 (@1052 @849) +@1473 := @1202 @953 +@1475 := @966 @117 @28 +@1490 := (hbind : @1472) -> + (hF : @1338) -> + (hA : @1473 @1475) -> + (hne : @987 @1450 @992) -> @1075 (fun (ro : @1074) => @1076 (@1341 @1375 @4) (@1206 @1245 @4)) +@1493 := @1467 (@428 @1043 @1469) +@1494 := @1202 @959 +@1496 := @966 @28 @30 +@1510 := (hF : @1338) -> + (hA : @1494 @1496) -> + (hne : @987 @1475 @992) -> @1075 (fun (ro : @1074) => @1076 (@1341 @1413 @4) (@1206 @1288 @4)) +@1513 := @1493 (@428 @1055 @1199) +@1527 := (hA : @1202 @833 @968) -> + (hne : @987 @1496 @992) -> @1075 (fun (ro : @1074) => @1076 (@1341 @1450 @4) (@1206 @946 @4)) +@1528 := @1513 @983 +@1539 := (hne : @987 @968 @992) -> + @1075 (fun (ro : @1074) => @1076 (@1341 @1475 @4) (@1206 @953 @4)) +@1540 := @1528 @1005 +@1546 := @1076 (@1341 @1496 @4) (@1206 @959 @4) +@1548 := @1075 (fun (ro : @1074) => @1546) +@1550 := @1075 (fun (__e_ro : @1074) => @1546) +@1555 := LexLeanPreservation.Rust.RepresentableL (@830 (@72 @34 @71)) +@1556 := (__e_hrep : @1555) -> @1550 +@1557 := fun (__e_hrep : @1555) => @1540 +@1558 := (b : @27) -> @1556 +@1559 := fun (b : @27) => @1557 +@1560 := (a : @27) -> @1558 +@1561 := fun (a : @27) => @1559 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustCore.lean deleted file mode 100644 index 4f9e332e5..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (v : (Option Nat)) (r : (Except Bool Nat)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) v), ((_root_.LexLeanPreservation.encExcept _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.nat) r)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.denote v r) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) v), ((_root_.LexLeanPreservation.encExcept _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.nat) r)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encOption _root_.LexLeanPreservation.Rust.wt_nat) v) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encExcept _root_.LexLeanPreservation.Rust.wt_bool _root_.LexLeanPreservation.Rust.wt_nat) r) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.root v r) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustCore.lex.tex new file mode 100644 index 000000000..fb48bd2b7 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustCore.lex.tex @@ -0,0 +1,615 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore.root : @1260 := @1261 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore.flags +@3 := Nat +@4 := Option.{0} +@5 := @4 @3 +@6 := #2 +@7 := LexLeanTarget.TargetSyntax.Value.nat +@8 := LexLeanPreservation.encOption +@9 := @8 @3 +@10 := @9 @7 +@11 := @10 @6 +@12 := LexLeanTarget.TargetSyntax.Ty.nat +@13 := LexLeanTarget.TargetSyntax.Ty.option +@14 := @13 @12 +@15 := #0 +@16 := LexLeanTarget.TargetSyntax.Program +@17 := LexLeanPreservation.Rust.RCrate +@18 := LexLeanPreservation.Rust.Flags +@19 := LexLeanPreservation.Rust.WT +@20 := #3 +@22 := @19 @20 @6 +@23 := #1 +@24 := @22 @23 +@25 := @7 @15 +@31 := {p : @16} -> {c : @17} -> {A : @18} -> (n : @3) -> @24 @25 @12 +@33 := LexLeanPreservation.Rust.wt_nat @0 +@34 := @19 @0 +@36 := @34 @6 @23 +@41 := {c : @17} -> {A : @18} -> (n : @3) -> @36 @25 @12 +@42 := @33 @1 +@43 := @34 @1 +@44 := @43 @23 +@48 := {A : @18} -> (n : @3) -> @44 @25 @12 +@49 := @42 @2 +@50 := @43 @2 +@51 := @50 @25 +@52 := @51 @12 +@53 := (n : @3) -> @52 +@55 := fun (__x : @3) => @49 @15 +@56 := Sort 1 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := (a._@._internal._hyg.#0 : @15) -> @57 +@59 := LexLeanTarget.TargetSyntax.Ty +@60 := #6 +@61 := @19 @60 +@62 := #5 +@63 := @61 @62 +@64 := #4 +@65 := @63 @64 +@66 := @6 @15 +@69 := (x : @6) -> @65 @66 @23 +@70 := @4 @20 +@71 := #7 +@74 := @19 @71 @60 @62 +@77 := @8 @64 @20 @15 +@78 := @74 @77 +@79 := @13 @6 +@88 := {p : @16} -> + {c : @17} -> {A : @18} -> {α : @56} -> {e : @58} -> {t : @59} -> (h : @69) -> (o : @70) -> @78 @79 +@90 := LexLeanPreservation.Rust.wt_encOption @0 +@92 := @34 @62 @64 +@106 := {c : @17} -> + {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @6) -> @92 @66 @23) -> (o : @70) -> @34 @60 @62 @77 @79 +@107 := @90 @1 +@108 := @43 @64 +@120 := {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @6) -> @108 @66 @23) -> (o : @70) -> @43 @62 @77 @79 +@121 := @107 @2 +@123 := @50 @66 @23 +@131 := {α : @56} -> {e : @58} -> {t : @59} -> (h : (x : @6) -> @123) -> (o : @70) -> @50 @77 @79 +@132 := @121 @3 +@133 := (a._@._internal._hyg.#0 : @3) -> @57 +@142 := {e : @133} -> {t : @59} -> (h : (x : @3) -> @123) -> (o : @5) -> @50 (@9 @20 @15) @79 +@143 := @132 @7 +@145 := (x : @3) -> @51 @23 +@147 := @50 (@10 @15) +@151 := {t : @59} -> (h : @145) -> (o : @5) -> @147 @79 +@152 := @143 @12 +@153 := (x : @3) -> @52 +@156 := (h : @153) -> (o : @5) -> @147 @14 +@158 := @152 @55 @6 +@160 := @50 @11 @14 +@161 := Bool +@162 := Except.{0, 0} +@163 := @162 @161 +@164 := @163 @3 +@165 := LexLeanTarget.TargetSyntax.Value.bool +@166 := LexLeanPreservation.encExcept +@167 := @166 @161 +@168 := @167 @3 +@169 := @168 @165 +@170 := @169 @7 +@171 := @170 @23 +@172 := LexLeanTarget.TargetSyntax.Ty.bool +@173 := LexLeanTarget.TargetSyntax.Ty.result +@174 := @173 @12 +@175 := @174 @172 +@176 := @165 @15 +@182 := {p : @16} -> {c : @17} -> {A : @18} -> (b : @161) -> @24 @176 @172 +@184 := LexLeanPreservation.Rust.wt_bool @0 +@189 := {c : @17} -> {A : @18} -> (b : @161) -> @36 @176 @172 +@190 := @184 @1 +@194 := {A : @18} -> (b : @161) -> @44 @176 @172 +@195 := @190 @2 +@196 := @50 @176 +@197 := @196 @172 +@198 := (b : @161) -> @197 +@200 := fun (__x : @161) => @195 @15 +@201 := (a._@._internal._hyg.#0 : @23) -> @57 +@202 := #9 +@203 := @19 @202 +@204 := #8 +@206 := @203 @204 @71 +@207 := @64 @15 +@210 := (x : @62) -> @206 @207 @23 +@211 := #10 +@217 := (x : @62) -> @19 @211 @202 @204 @207 @20 +@219 := @162 @71 @60 +@220 := #11 +@223 := @19 @220 @211 @202 +@228 := @166 @204 @71 @60 @62 @15 +@229 := @223 @228 +@231 := @173 @64 @20 +@244 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {ε : @56} -> + {α : @56} -> + {ee : @201} -> + {ea : @201} -> {s : @59} -> {t : @59} -> (he : @210) -> (ha : @217) -> (x : @219) -> @229 @231 +@246 := LexLeanPreservation.Rust.wt_encExcept @0 +@271 := {c : @17} -> + {A : @18} -> + {ε : @56} -> + {α : @56} -> + {ee : @201} -> + {ea : @201} -> + {s : @59} -> + {t : @59} -> + (he : (x : @62) -> @34 @204 @71 @207 @23) -> + (ha : (x : @62) -> @34 @202 @204 @207 @20) -> (x : @219) -> @34 @211 @202 @228 @231 +@272 := @246 @1 +@293 := {A : @18} -> + {ε : @56} -> + {α : @56} -> + {ee : @201} -> + {ea : @201} -> + {s : @59} -> + {t : @59} -> + (he : (x : @62) -> @43 @71 @207 @23) -> + (ha : (x : @62) -> @43 @204 @207 @20) -> (x : @219) -> @43 @202 @228 @231 +@294 := @272 @2 +@295 := @50 @207 +@296 := @295 @23 +@297 := (x : @62) -> @296 +@298 := @295 @20 +@299 := (x : @62) -> @298 +@310 := {ε : @56} -> + {α : @56} -> + {ee : @201} -> + {ea : @201} -> {s : @59} -> {t : @59} -> (he : @297) -> (ha : @299) -> (x : @219) -> @50 @228 @231 +@311 := @294 @161 +@312 := (a._@._internal._hyg.#0 : @161) -> @57 +@313 := (x : @161) -> @296 +@328 := {α : @56} -> + {ee : @312} -> + {ea : @201} -> + {s : @59} -> + {t : @59} -> (he : @313) -> (ha : @299) -> (x : @163 @60) -> @50 (@167 @71 @60 @62 @15) @231 +@329 := @311 @3 +@330 := (x : @3) -> @298 +@342 := {ee : @312} -> + {ea : @133} -> + {s : @59} -> {t : @59} -> (he : @313) -> (ha : @330) -> (x : @164) -> @50 (@168 @60 @62 @15) @231 +@343 := @329 @165 +@345 := (x : @161) -> @196 @23 +@355 := {ea : @133} -> + {s : @59} -> {t : @59} -> (he : @345) -> (ha : @330) -> (x : @164) -> @50 (@169 @62 @15) @231 +@356 := @343 @7 +@358 := (x : @3) -> @51 @20 +@359 := @170 @15 +@360 := @50 @359 +@366 := {s : @59} -> {t : @59} -> (he : @345) -> (ha : @358) -> (x : @164) -> @360 @231 +@367 := @356 @12 +@373 := {t : @59} -> (he : @345) -> (ha : @153) -> (x : @164) -> @360 (@174 @20) +@374 := @367 @172 +@379 := (he : (x : @161) -> @197) -> (ha : @153) -> (x : @164) -> @360 @175 +@382 := @374 @200 @55 @23 +@384 := @50 @171 @175 +@385 := List.nil.{0} +@386 := List.cons.{0} +@387 := @385 @57 +@388 := @386 @57 +@390 := @388 @171 @387 +@392 := @388 @11 @390 +@395 := Prod.{0, 0} @3 @57 +@396 := 1 +@399 := Prod.mk.{0, 0} @3 @57 +@400 := @399 @396 +@401 := @400 @171 +@402 := 0 +@403 := @399 @402 +@404 := @403 @11 +@405 := @385 @395 +@406 := @386 @395 +@408 := @406 @404 @405 +@410 := @406 @401 @408 +@411 := Bool.true +@412 := LexLeanTarget.TargetSyntax.Function +@413 := LexLeanTarget.TargetSyntax.Program.functions +@414 := @413 @0 +@415 := @385 @3 +@416 := @385 @59 +@417 := LexLeanTarget.TargetSyntax.Ty.unit +@418 := LexLeanTarget.TargetSyntax.Value.unit +@421 := LexLeanTarget.TargetSyntax.Expr.value @417 @418 +@426 := LexLeanTarget.TargetSyntax.Function.mk @415 @416 @417 @421 +@431 := List.getD.{0} @412 @414 @402 @426 +@435 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore.root @15 @402 +@436 := LexLeanPreservation.Rust.WTL +@444 := {p : @16} -> {c : @17} -> {A : @18} -> @436 @6 @23 @15 @387 @416 +@446 := LexLeanPreservation.Rust.wtl_nil @0 +@447 := @436 @0 +@453 := {c : @17} -> {A : @18} -> @447 @23 @15 @387 @416 +@454 := @446 @1 +@455 := @447 @1 +@459 := {A : @18} -> @455 @15 @387 @416 +@460 := @454 @2 +@461 := @455 @2 +@462 := @461 @387 +@463 := @462 @416 +@464 := List.{0} +@465 := @464 @57 +@466 := @464 @59 +@468 := @65 @20 @6 +@473 := @436 @71 @60 @62 @6 @23 +@476 := @436 @204 @71 @60 +@478 := @388 @62 @20 +@479 := @476 @478 +@480 := @386 @59 +@482 := @480 @64 @6 +@492 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {v : @57} -> {t : @59} -> {vs : @465} -> {ts : @466} -> (h : @468) -> (hs : @473) -> @479 @482 +@494 := LexLeanPreservation.Rust.wtl_cons @0 +@512 := {c : @17} -> + {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @465} -> + {ts : @466} -> (h : @92 @20 @6) -> (hs : @447 @60 @62 @6 @23) -> @447 @71 @60 @478 @482 +@513 := @494 @1 +@528 := {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @465} -> {ts : @466} -> (h : @108 @20 @6) -> (hs : @455 @62 @6 @23) -> @455 @60 @478 @482 +@529 := @513 @2 +@531 := @50 @20 @6 +@533 := @461 @6 @23 +@541 := {v : @57} -> + {t : @59} -> {vs : @465} -> {ts : @466} -> (h : @531) -> (hs : @533) -> @461 @478 @482 +@542 := @529 @171 +@543 := @170 @64 +@545 := @50 @543 @6 +@546 := @170 @60 +@547 := @388 @546 +@555 := {t : @59} -> {vs : @465} -> {ts : @466} -> (h : @545) -> (hs : @533) -> @461 (@547 @20) @482 +@556 := @542 @175 +@557 := @170 @20 +@559 := @50 @557 @175 +@560 := @170 @62 +@561 := @388 @560 +@563 := @461 (@561 @20) +@564 := @480 @175 +@565 := @564 @6 +@570 := {vs : @465} -> {ts : @466} -> (h : @559) -> (hs : @533) -> @563 @565 +@571 := @556 @387 +@572 := @170 @6 +@574 := @50 @572 @175 +@575 := @462 @23 +@577 := @388 @543 @387 +@582 := {ts : @466} -> (h : @574) -> (hs : @575) -> @461 @577 @565 +@583 := @571 @416 +@585 := @388 @557 @387 +@586 := @461 @585 +@587 := @564 @416 +@590 := (h : @384) -> (hs : @463) -> @586 @587 +@591 := @583 @382 +@593 := @388 @572 @387 +@595 := @461 @593 @587 +@596 := (hs : @463) -> @595 +@597 := @591 @460 +@599 := @461 @390 @587 +@600 := @529 @11 +@601 := @10 @62 +@603 := @50 @601 @6 +@604 := @10 @71 +@605 := @388 @604 +@613 := {t : @59} -> {vs : @465} -> {ts : @466} -> (h : @603) -> (hs : @533) -> @461 (@605 @20) @482 +@614 := @600 @14 +@615 := @10 @64 +@617 := @50 @615 @14 +@618 := @10 @60 +@619 := @388 @618 +@621 := @461 (@619 @20) +@622 := @480 @14 +@623 := @622 @6 +@628 := {vs : @465} -> {ts : @466} -> (h : @617) -> (hs : @533) -> @621 @623 +@629 := @614 @390 +@630 := @10 @20 +@632 := @50 @630 @14 +@633 := @586 @23 +@635 := @388 @601 @577 +@636 := @461 @635 +@640 := {ts : @466} -> (h : @632) -> (hs : @633) -> @636 @623 +@641 := @629 @587 +@643 := @388 @615 @585 +@644 := @461 @643 +@645 := @622 @587 +@648 := (h : @160) -> (hs : @595) -> @644 @645 +@649 := @641 @158 +@651 := @388 @630 @593 +@652 := @461 @651 +@654 := (hs : @599) -> @652 @645 +@655 := @649 @597 +@656 := @461 @392 +@657 := @656 @645 +@658 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.denote +@660 := @658 @6 @23 +@661 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.__fits_0 +@663 := @661 @6 @23 +@667 := @7 (Coverage.Main.options @6 @23) +@670 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.root @6 @23 +@671 := Ne.{1} +@672 := LexLeanPreservation.Obs +@673 := @671 @672 +@674 := LexLeanPreservation.Rel +@677 := @673 (@674 @23 @15) +@678 := LexLeanPreservation.Obs.stuck +@681 := (f : @161) -> (v : @57) -> @677 @678 +@683 := LexLeanPreservation.Rust.rel_ne_stuck @663 +@690 := (v : @57) -> @673 (@674 (@661 @20 @6) @15) @678 +@691 := @683 @667 +@695 := @673 (@674 @663 @667) @678 +@696 := @464 @395 +@697 := LexLeanPreservation.Rust.FunSem +@703 := (n : @3) -> @697 @202 @204 @71 @15 @60 +@704 := Eq.{1} +@705 := @4 @412 +@706 := @704 @705 +@713 := LexLeanRuntime.index (@464 @412) @412 (LexLeanRuntime.instIndexableList @412) +@717 := @706 (@713 (@413 @202) @60) +@718 := Option.some.{0} +@719 := @718 @412 +@720 := @719 @62 +@721 := @717 @720 +@725 := @436 @211 @202 @204 @62 +@726 := LexLeanTarget.TargetSyntax.Function.types +@727 := @726 @60 +@728 := @725 @727 +@729 := @4 @696 +@730 := @704 @729 +@731 := LexLeanTarget.TargetSemantics.bindAll +@732 := LexLeanTarget.TargetSyntax.Function.parameters +@737 := @730 (@731 (@732 @71) @60 @405) +@738 := @718 @696 +@739 := @738 @62 +@740 := @737 @739 +@741 := @4 @161 +@742 := @704 @741 +@743 := LexLeanPreservation.Rust.fnFallible +@746 := @742 (@743 @220 @202) +@747 := @718 @161 +@748 := @747 @62 +@749 := @746 @748 +@750 := LexLeanPreservation.RunConv +@751 := #13 +@755 := @750 @751 @211 @204 @62 +@757 := @673 @60 @678 +@758 := Exists.{1} +@759 := LexLeanPreservation.Rust.ROut +@760 := @758 @759 +@761 := And +@762 := LexLeanPreservation.Rust.RealizesFn +@766 := @761 (@762 @202 @204 @15) +@767 := LexLeanPreservation.Rust.RCI +@769 := @767 #15 +@770 := LexLeanPreservation.Rust.fnIdent +@771 := @770 @751 +@778 := (hne : @757) -> @760 (fun (ro : @759) => @766 (@769 @771 @220 @15)) +@793 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @412} -> + {args : @465} -> + {env : @696} -> + {F : @161} -> + {o : @672} -> + (hB : @703) -> + (hfn : @721) -> (hwt : @728) -> (hbind : @740) -> (hF : @749) -> (hA : @755) -> @778 +@795 := LexLeanPreservation.Rust.compose @0 +@796 := @697 @0 +@801 := (n : @3) -> @796 @204 @71 @15 @60 +@802 := @713 @414 +@805 := @706 (@802 @60) @720 +@809 := @447 @202 @204 @62 @727 +@810 := @750 @0 +@813 := @810 @211 @204 @62 +@827 := {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @412} -> + {args : @465} -> + {env : @696} -> + {F : @161} -> + {o : @672} -> + (hB : @801) -> + (hfn : @805) -> (hwt : @809) -> (hbind : @740) -> (hF : @749) -> (hA : @813) -> @778 +@828 := @795 @1 +@829 := @796 @1 +@833 := (n : @3) -> @829 @71 @15 @60 +@836 := @455 @204 @62 @727 +@837 := @743 @1 +@840 := @742 (@837 @202) @748 +@841 := @767 @1 +@851 := (hbind : @740) -> + (hF : @840) -> (hA : @813) -> (hne : @757) -> @760 (fun (ro : @759) => @766 (@841 @771 @220 @15)) +@861 := {A : @18} -> + {f : @3} -> + {fn : @412} -> + {args : @465} -> + {env : @696} -> {F : @161} -> {o : @672} -> (hB : @833) -> (hfn : @805) -> (hwt : @836) -> @851 +@862 := @828 @2 +@864 := @829 @2 @15 +@866 := (n : @3) -> @864 @60 +@867 := @461 @62 +@868 := @867 @727 +@877 := {f : @3} -> + {fn : @412} -> + {args : @465} -> + {env : @696} -> {F : @161} -> {o : @672} -> (hB : @866) -> (hfn : @805) -> (hwt : @868) -> @851 +@878 := @862 @402 +@880 := (n : @3) -> @864 @402 +@881 := @802 @402 +@882 := @706 @881 +@883 := @882 @720 +@884 := @837 @402 +@885 := @742 @884 +@886 := @885 @748 +@887 := @810 @402 +@889 := @887 @204 @62 +@891 := @841 (@770 @402) +@899 := (hF : @886) -> (hA : @889) -> (hne : @757) -> @760 (fun (ro : @759) => @766 (@891 @220 @15)) +@908 := {fn : @412} -> + {args : @465} -> + {env : @696} -> + {F : @161} -> {o : @672} -> (hB : @880) -> (hfn : @883) -> (hwt : @868) -> (hbind : @740) -> @899 +@909 := @878 @431 +@911 := @882 (@719 @431) +@912 := @726 @431 +@913 := @867 @912 +@915 := @731 (@732 @431) +@927 := {args : @465} -> + {env : @696} -> + {F : @161} -> + {o : @672} -> + (hB : @880) -> (hfn : @911) -> (hwt : @913) -> (hbind : @730 (@915 @60 @405) @739) -> @899 +@928 := @909 @392 +@930 := @605 (@547 @387) +@932 := @461 @930 @912 +@938 := @388 (@10 @204) (@388 (@170 @71) @387) +@942 := @730 (@915 @938 @405) @739 +@948 := @388 (@10 @211) (@388 (@170 @202) @387) +@950 := @887 @948 @62 +@952 := @388 (@10 @751) +@953 := #12 +@972 := {env : @696} -> + {F : @161} -> + {o : @672} -> + (hB : @880) -> + (hfn : @911) -> + (hwt : @932) -> + (hbind : @942) -> + (hF : @886) -> + (hA : @950) -> + (hne : @757) -> @760 (fun (ro : @759) => @766 (@891 (@952 (@388 (@170 @953) @387)) @15)) +@973 := @928 @410 +@975 := @619 (@561 @387) +@977 := @461 @975 @912 +@988 := @730 (@915 @930 @405) (@738 (@406 (@400 @546) (@406 (@403 @604) @405))) +@994 := @388 (@10 @202) (@388 (@170 @204) @387) +@1016 := {F : @161} -> + {o : @672} -> + (hB : @880) -> + (hfn : @911) -> + (hwt : @977) -> + (hbind : @988) -> + (hF : @886) -> + (hA : @887 @994 @62) -> + (hne : @757) -> + @760 (fun (ro : @759) => @766 (@891 (@388 (@10 @953) (@388 (@170 @220) @387)) @15)) +@1017 := @973 @411 +@1018 := @636 @912 +@1029 := @730 (@915 @975 @405) (@738 (@406 (@400 @560) (@406 (@403 @618) @405))) +@1031 := @885 (@747 @411) +@1033 := @887 @938 @62 +@1034 := @762 @411 +@1056 := {o : @672} -> + (hB : @880) -> + (hfn : @911) -> + (hwt : @1018) -> + (hbind : @1029) -> + (hF : @1031) -> + (hA : @1033) -> + (hne : @757) -> + @760 + (fun (ro : @759) => @761 (@1034 @204 @15) (@891 (@388 (@10 @220) (@388 (@170 @211) @387)) @15)) +@1057 := @1017 @660 +@1058 := @644 @912 +@1069 := @730 (@915 @635 @405) (@738 (@406 (@400 @543) (@406 (@403 @601) @405))) +@1070 := @887 @930 +@1072 := @658 @71 @60 +@1073 := @1070 @1072 +@1075 := @658 @204 @71 +@1094 := (hB : @880) -> + (hfn : @911) -> + (hwt : @1058) -> + (hbind : @1069) -> + (hF : @1031) -> + (hA : @1073) -> + (hne : @673 @1075 @678) -> + @760 (fun (ro : @759) => @761 (@1034 (@658 @211 @202) @15) (@891 @948 @15)) +@1095 := @1057 @435 +@1096 := @652 @912 +@1107 := @730 (@915 @643 @405) (@738 (@406 (@400 @557) (@406 (@403 @615) @405))) +@1108 := @887 @975 +@1110 := @658 @60 @62 +@1129 := (hfn : @911) -> + (hwt : @1096) -> + (hbind : @1107) -> + (hF : @1031) -> + (hA : @1108 @1110) -> + (hne : @673 @1072 @678) -> + @760 (fun (ro : @759) => @761 (@1034 (@658 @202 @204) @15) (@891 @994 @15)) +@1130 := Eq.refl.{1} +@1133 := @1095 (@1130 @705 @881) +@1134 := @656 @912 +@1145 := @730 (@915 @651 @405) (@738 (@406 (@400 @572) (@406 (@403 @630) @405))) +@1146 := @887 @635 +@1148 := @658 @62 @64 +@1164 := (hwt : @1134) -> + (hbind : @1145) -> + (hF : @1031) -> + (hA : @1146 @1148) -> + (hne : @673 @1110 @678) -> @760 (fun (ro : @759) => @761 (@1034 @1075 @15) (@891 @938 @15)) +@1165 := @1133 @655 +@1167 := @915 @392 @405 +@1170 := @730 @1167 (@738 @410) +@1171 := @887 @643 +@1173 := @658 @64 @20 +@1188 := (hbind : @1170) -> + (hF : @1031) -> + (hA : @1171 @1173) -> + (hne : @673 @1148 @678) -> @760 (fun (ro : @759) => @761 (@1034 @1072 @15) (@891 @930 @15)) +@1191 := @1165 (@1130 @729 @1167) +@1192 := @887 @651 +@1194 := @658 @20 @6 +@1208 := (hF : @1031) -> + (hA : @1192 @1194) -> + (hne : @673 @1173 @678) -> @760 (fun (ro : @759) => @761 (@1034 @1110 @15) (@891 @975 @15)) +@1211 := @1191 (@1130 @741 @884) +@1225 := (hA : @887 @392 @660) -> + (hne : @673 @1194 @678) -> @760 (fun (ro : @759) => @761 (@1034 @1148 @15) (@891 @635 @15)) +@1226 := @1211 @670 +@1237 := (hne : @673 @660 @678) -> @760 (fun (ro : @759) => @761 (@1034 @1173 @15) (@891 @643 @15)) +@1238 := @1226 @691 +@1244 := @761 (@1034 @1194 @15) (@891 @651 @15) +@1246 := @760 (fun (ro : @759) => @1244) +@1248 := @760 (fun (__e_ro : @759) => @1244) +@1249 := LexLeanPreservation.Rust.RepresentableL +@1250 := @10 @23 +@1252 := @388 @359 @387 +@1255 := @1249 (@388 @1250 @1252) +@1256 := (__e_hrep : @1255) -> @1248 +@1257 := fun (__e_hrep : @1255) => @1238 +@1258 := (r : @164) -> @1256 +@1259 := fun (r : @164) => @1257 +@1260 := (v : @5) -> @1258 +@1261 := fun (v : @5) => @1259 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustStd.lean deleted file mode 100644 index 4d7bf5182..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (v : (Option Nat)) (r : (Except Bool Nat)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) v), ((_root_.LexLeanPreservation.encExcept _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.nat) r)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.denote v r) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) v), ((_root_.LexLeanPreservation.encExcept _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.nat) r)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encOption _root_.LexLeanPreservation.Rust.wt_nat) v) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encExcept _root_.LexLeanPreservation.Rust.wt_bool _root_.LexLeanPreservation.Rust.wt_nat) r) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.root v r) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustStd.lex.tex new file mode 100644 index 000000000..b479c18db --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustStd.lex.tex @@ -0,0 +1,615 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd.root : @1260 := @1261 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd.flags +@3 := Nat +@4 := Option.{0} +@5 := @4 @3 +@6 := #2 +@7 := LexLeanTarget.TargetSyntax.Value.nat +@8 := LexLeanPreservation.encOption +@9 := @8 @3 +@10 := @9 @7 +@11 := @10 @6 +@12 := LexLeanTarget.TargetSyntax.Ty.nat +@13 := LexLeanTarget.TargetSyntax.Ty.option +@14 := @13 @12 +@15 := #0 +@16 := LexLeanTarget.TargetSyntax.Program +@17 := LexLeanPreservation.Rust.RCrate +@18 := LexLeanPreservation.Rust.Flags +@19 := LexLeanPreservation.Rust.WT +@20 := #3 +@22 := @19 @20 @6 +@23 := #1 +@24 := @22 @23 +@25 := @7 @15 +@31 := {p : @16} -> {c : @17} -> {A : @18} -> (n : @3) -> @24 @25 @12 +@33 := LexLeanPreservation.Rust.wt_nat @0 +@34 := @19 @0 +@36 := @34 @6 @23 +@41 := {c : @17} -> {A : @18} -> (n : @3) -> @36 @25 @12 +@42 := @33 @1 +@43 := @34 @1 +@44 := @43 @23 +@48 := {A : @18} -> (n : @3) -> @44 @25 @12 +@49 := @42 @2 +@50 := @43 @2 +@51 := @50 @25 +@52 := @51 @12 +@53 := (n : @3) -> @52 +@55 := fun (__x : @3) => @49 @15 +@56 := Sort 1 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := (a._@._internal._hyg.#0 : @15) -> @57 +@59 := LexLeanTarget.TargetSyntax.Ty +@60 := #6 +@61 := @19 @60 +@62 := #5 +@63 := @61 @62 +@64 := #4 +@65 := @63 @64 +@66 := @6 @15 +@69 := (x : @6) -> @65 @66 @23 +@70 := @4 @20 +@71 := #7 +@74 := @19 @71 @60 @62 +@77 := @8 @64 @20 @15 +@78 := @74 @77 +@79 := @13 @6 +@88 := {p : @16} -> + {c : @17} -> {A : @18} -> {α : @56} -> {e : @58} -> {t : @59} -> (h : @69) -> (o : @70) -> @78 @79 +@90 := LexLeanPreservation.Rust.wt_encOption @0 +@92 := @34 @62 @64 +@106 := {c : @17} -> + {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @6) -> @92 @66 @23) -> (o : @70) -> @34 @60 @62 @77 @79 +@107 := @90 @1 +@108 := @43 @64 +@120 := {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @6) -> @108 @66 @23) -> (o : @70) -> @43 @62 @77 @79 +@121 := @107 @2 +@123 := @50 @66 @23 +@131 := {α : @56} -> {e : @58} -> {t : @59} -> (h : (x : @6) -> @123) -> (o : @70) -> @50 @77 @79 +@132 := @121 @3 +@133 := (a._@._internal._hyg.#0 : @3) -> @57 +@142 := {e : @133} -> {t : @59} -> (h : (x : @3) -> @123) -> (o : @5) -> @50 (@9 @20 @15) @79 +@143 := @132 @7 +@145 := (x : @3) -> @51 @23 +@147 := @50 (@10 @15) +@151 := {t : @59} -> (h : @145) -> (o : @5) -> @147 @79 +@152 := @143 @12 +@153 := (x : @3) -> @52 +@156 := (h : @153) -> (o : @5) -> @147 @14 +@158 := @152 @55 @6 +@160 := @50 @11 @14 +@161 := Bool +@162 := Except.{0, 0} +@163 := @162 @161 +@164 := @163 @3 +@165 := LexLeanTarget.TargetSyntax.Value.bool +@166 := LexLeanPreservation.encExcept +@167 := @166 @161 +@168 := @167 @3 +@169 := @168 @165 +@170 := @169 @7 +@171 := @170 @23 +@172 := LexLeanTarget.TargetSyntax.Ty.bool +@173 := LexLeanTarget.TargetSyntax.Ty.result +@174 := @173 @12 +@175 := @174 @172 +@176 := @165 @15 +@182 := {p : @16} -> {c : @17} -> {A : @18} -> (b : @161) -> @24 @176 @172 +@184 := LexLeanPreservation.Rust.wt_bool @0 +@189 := {c : @17} -> {A : @18} -> (b : @161) -> @36 @176 @172 +@190 := @184 @1 +@194 := {A : @18} -> (b : @161) -> @44 @176 @172 +@195 := @190 @2 +@196 := @50 @176 +@197 := @196 @172 +@198 := (b : @161) -> @197 +@200 := fun (__x : @161) => @195 @15 +@201 := (a._@._internal._hyg.#0 : @23) -> @57 +@202 := #9 +@203 := @19 @202 +@204 := #8 +@206 := @203 @204 @71 +@207 := @64 @15 +@210 := (x : @62) -> @206 @207 @23 +@211 := #10 +@217 := (x : @62) -> @19 @211 @202 @204 @207 @20 +@219 := @162 @71 @60 +@220 := #11 +@223 := @19 @220 @211 @202 +@228 := @166 @204 @71 @60 @62 @15 +@229 := @223 @228 +@231 := @173 @64 @20 +@244 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {ε : @56} -> + {α : @56} -> + {ee : @201} -> + {ea : @201} -> {s : @59} -> {t : @59} -> (he : @210) -> (ha : @217) -> (x : @219) -> @229 @231 +@246 := LexLeanPreservation.Rust.wt_encExcept @0 +@271 := {c : @17} -> + {A : @18} -> + {ε : @56} -> + {α : @56} -> + {ee : @201} -> + {ea : @201} -> + {s : @59} -> + {t : @59} -> + (he : (x : @62) -> @34 @204 @71 @207 @23) -> + (ha : (x : @62) -> @34 @202 @204 @207 @20) -> (x : @219) -> @34 @211 @202 @228 @231 +@272 := @246 @1 +@293 := {A : @18} -> + {ε : @56} -> + {α : @56} -> + {ee : @201} -> + {ea : @201} -> + {s : @59} -> + {t : @59} -> + (he : (x : @62) -> @43 @71 @207 @23) -> + (ha : (x : @62) -> @43 @204 @207 @20) -> (x : @219) -> @43 @202 @228 @231 +@294 := @272 @2 +@295 := @50 @207 +@296 := @295 @23 +@297 := (x : @62) -> @296 +@298 := @295 @20 +@299 := (x : @62) -> @298 +@310 := {ε : @56} -> + {α : @56} -> + {ee : @201} -> + {ea : @201} -> {s : @59} -> {t : @59} -> (he : @297) -> (ha : @299) -> (x : @219) -> @50 @228 @231 +@311 := @294 @161 +@312 := (a._@._internal._hyg.#0 : @161) -> @57 +@313 := (x : @161) -> @296 +@328 := {α : @56} -> + {ee : @312} -> + {ea : @201} -> + {s : @59} -> + {t : @59} -> (he : @313) -> (ha : @299) -> (x : @163 @60) -> @50 (@167 @71 @60 @62 @15) @231 +@329 := @311 @3 +@330 := (x : @3) -> @298 +@342 := {ee : @312} -> + {ea : @133} -> + {s : @59} -> {t : @59} -> (he : @313) -> (ha : @330) -> (x : @164) -> @50 (@168 @60 @62 @15) @231 +@343 := @329 @165 +@345 := (x : @161) -> @196 @23 +@355 := {ea : @133} -> + {s : @59} -> {t : @59} -> (he : @345) -> (ha : @330) -> (x : @164) -> @50 (@169 @62 @15) @231 +@356 := @343 @7 +@358 := (x : @3) -> @51 @20 +@359 := @170 @15 +@360 := @50 @359 +@366 := {s : @59} -> {t : @59} -> (he : @345) -> (ha : @358) -> (x : @164) -> @360 @231 +@367 := @356 @12 +@373 := {t : @59} -> (he : @345) -> (ha : @153) -> (x : @164) -> @360 (@174 @20) +@374 := @367 @172 +@379 := (he : (x : @161) -> @197) -> (ha : @153) -> (x : @164) -> @360 @175 +@382 := @374 @200 @55 @23 +@384 := @50 @171 @175 +@385 := List.nil.{0} +@386 := List.cons.{0} +@387 := @385 @57 +@388 := @386 @57 +@390 := @388 @171 @387 +@392 := @388 @11 @390 +@395 := Prod.{0, 0} @3 @57 +@396 := 1 +@399 := Prod.mk.{0, 0} @3 @57 +@400 := @399 @396 +@401 := @400 @171 +@402 := 0 +@403 := @399 @402 +@404 := @403 @11 +@405 := @385 @395 +@406 := @386 @395 +@408 := @406 @404 @405 +@410 := @406 @401 @408 +@411 := Bool.true +@412 := LexLeanTarget.TargetSyntax.Function +@413 := LexLeanTarget.TargetSyntax.Program.functions +@414 := @413 @0 +@415 := @385 @3 +@416 := @385 @59 +@417 := LexLeanTarget.TargetSyntax.Ty.unit +@418 := LexLeanTarget.TargetSyntax.Value.unit +@421 := LexLeanTarget.TargetSyntax.Expr.value @417 @418 +@426 := LexLeanTarget.TargetSyntax.Function.mk @415 @416 @417 @421 +@431 := List.getD.{0} @412 @414 @402 @426 +@435 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd.root @15 @402 +@436 := LexLeanPreservation.Rust.WTL +@444 := {p : @16} -> {c : @17} -> {A : @18} -> @436 @6 @23 @15 @387 @416 +@446 := LexLeanPreservation.Rust.wtl_nil @0 +@447 := @436 @0 +@453 := {c : @17} -> {A : @18} -> @447 @23 @15 @387 @416 +@454 := @446 @1 +@455 := @447 @1 +@459 := {A : @18} -> @455 @15 @387 @416 +@460 := @454 @2 +@461 := @455 @2 +@462 := @461 @387 +@463 := @462 @416 +@464 := List.{0} +@465 := @464 @57 +@466 := @464 @59 +@468 := @65 @20 @6 +@473 := @436 @71 @60 @62 @6 @23 +@476 := @436 @204 @71 @60 +@478 := @388 @62 @20 +@479 := @476 @478 +@480 := @386 @59 +@482 := @480 @64 @6 +@492 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {v : @57} -> {t : @59} -> {vs : @465} -> {ts : @466} -> (h : @468) -> (hs : @473) -> @479 @482 +@494 := LexLeanPreservation.Rust.wtl_cons @0 +@512 := {c : @17} -> + {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @465} -> + {ts : @466} -> (h : @92 @20 @6) -> (hs : @447 @60 @62 @6 @23) -> @447 @71 @60 @478 @482 +@513 := @494 @1 +@528 := {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @465} -> {ts : @466} -> (h : @108 @20 @6) -> (hs : @455 @62 @6 @23) -> @455 @60 @478 @482 +@529 := @513 @2 +@531 := @50 @20 @6 +@533 := @461 @6 @23 +@541 := {v : @57} -> + {t : @59} -> {vs : @465} -> {ts : @466} -> (h : @531) -> (hs : @533) -> @461 @478 @482 +@542 := @529 @171 +@543 := @170 @64 +@545 := @50 @543 @6 +@546 := @170 @60 +@547 := @388 @546 +@555 := {t : @59} -> {vs : @465} -> {ts : @466} -> (h : @545) -> (hs : @533) -> @461 (@547 @20) @482 +@556 := @542 @175 +@557 := @170 @20 +@559 := @50 @557 @175 +@560 := @170 @62 +@561 := @388 @560 +@563 := @461 (@561 @20) +@564 := @480 @175 +@565 := @564 @6 +@570 := {vs : @465} -> {ts : @466} -> (h : @559) -> (hs : @533) -> @563 @565 +@571 := @556 @387 +@572 := @170 @6 +@574 := @50 @572 @175 +@575 := @462 @23 +@577 := @388 @543 @387 +@582 := {ts : @466} -> (h : @574) -> (hs : @575) -> @461 @577 @565 +@583 := @571 @416 +@585 := @388 @557 @387 +@586 := @461 @585 +@587 := @564 @416 +@590 := (h : @384) -> (hs : @463) -> @586 @587 +@591 := @583 @382 +@593 := @388 @572 @387 +@595 := @461 @593 @587 +@596 := (hs : @463) -> @595 +@597 := @591 @460 +@599 := @461 @390 @587 +@600 := @529 @11 +@601 := @10 @62 +@603 := @50 @601 @6 +@604 := @10 @71 +@605 := @388 @604 +@613 := {t : @59} -> {vs : @465} -> {ts : @466} -> (h : @603) -> (hs : @533) -> @461 (@605 @20) @482 +@614 := @600 @14 +@615 := @10 @64 +@617 := @50 @615 @14 +@618 := @10 @60 +@619 := @388 @618 +@621 := @461 (@619 @20) +@622 := @480 @14 +@623 := @622 @6 +@628 := {vs : @465} -> {ts : @466} -> (h : @617) -> (hs : @533) -> @621 @623 +@629 := @614 @390 +@630 := @10 @20 +@632 := @50 @630 @14 +@633 := @586 @23 +@635 := @388 @601 @577 +@636 := @461 @635 +@640 := {ts : @466} -> (h : @632) -> (hs : @633) -> @636 @623 +@641 := @629 @587 +@643 := @388 @615 @585 +@644 := @461 @643 +@645 := @622 @587 +@648 := (h : @160) -> (hs : @595) -> @644 @645 +@649 := @641 @158 +@651 := @388 @630 @593 +@652 := @461 @651 +@654 := (hs : @599) -> @652 @645 +@655 := @649 @597 +@656 := @461 @392 +@657 := @656 @645 +@658 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.denote +@660 := @658 @6 @23 +@661 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.__fits_0 +@663 := @661 @6 @23 +@667 := @7 (Coverage.Main.options @6 @23) +@670 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.root @6 @23 +@671 := Ne.{1} +@672 := LexLeanPreservation.Obs +@673 := @671 @672 +@674 := LexLeanPreservation.Rel +@677 := @673 (@674 @23 @15) +@678 := LexLeanPreservation.Obs.stuck +@681 := (f : @161) -> (v : @57) -> @677 @678 +@683 := LexLeanPreservation.Rust.rel_ne_stuck @663 +@690 := (v : @57) -> @673 (@674 (@661 @20 @6) @15) @678 +@691 := @683 @667 +@695 := @673 (@674 @663 @667) @678 +@696 := @464 @395 +@697 := LexLeanPreservation.Rust.FunSem +@703 := (n : @3) -> @697 @202 @204 @71 @15 @60 +@704 := Eq.{1} +@705 := @4 @412 +@706 := @704 @705 +@713 := LexLeanRuntime.index (@464 @412) @412 (LexLeanRuntime.instIndexableList @412) +@717 := @706 (@713 (@413 @202) @60) +@718 := Option.some.{0} +@719 := @718 @412 +@720 := @719 @62 +@721 := @717 @720 +@725 := @436 @211 @202 @204 @62 +@726 := LexLeanTarget.TargetSyntax.Function.types +@727 := @726 @60 +@728 := @725 @727 +@729 := @4 @696 +@730 := @704 @729 +@731 := LexLeanTarget.TargetSemantics.bindAll +@732 := LexLeanTarget.TargetSyntax.Function.parameters +@737 := @730 (@731 (@732 @71) @60 @405) +@738 := @718 @696 +@739 := @738 @62 +@740 := @737 @739 +@741 := @4 @161 +@742 := @704 @741 +@743 := LexLeanPreservation.Rust.fnFallible +@746 := @742 (@743 @220 @202) +@747 := @718 @161 +@748 := @747 @62 +@749 := @746 @748 +@750 := LexLeanPreservation.RunConv +@751 := #13 +@755 := @750 @751 @211 @204 @62 +@757 := @673 @60 @678 +@758 := Exists.{1} +@759 := LexLeanPreservation.Rust.ROut +@760 := @758 @759 +@761 := And +@762 := LexLeanPreservation.Rust.RealizesFn +@766 := @761 (@762 @202 @204 @15) +@767 := LexLeanPreservation.Rust.RCI +@769 := @767 #15 +@770 := LexLeanPreservation.Rust.fnIdent +@771 := @770 @751 +@778 := (hne : @757) -> @760 (fun (ro : @759) => @766 (@769 @771 @220 @15)) +@793 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @412} -> + {args : @465} -> + {env : @696} -> + {F : @161} -> + {o : @672} -> + (hB : @703) -> + (hfn : @721) -> (hwt : @728) -> (hbind : @740) -> (hF : @749) -> (hA : @755) -> @778 +@795 := LexLeanPreservation.Rust.compose @0 +@796 := @697 @0 +@801 := (n : @3) -> @796 @204 @71 @15 @60 +@802 := @713 @414 +@805 := @706 (@802 @60) @720 +@809 := @447 @202 @204 @62 @727 +@810 := @750 @0 +@813 := @810 @211 @204 @62 +@827 := {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @412} -> + {args : @465} -> + {env : @696} -> + {F : @161} -> + {o : @672} -> + (hB : @801) -> + (hfn : @805) -> (hwt : @809) -> (hbind : @740) -> (hF : @749) -> (hA : @813) -> @778 +@828 := @795 @1 +@829 := @796 @1 +@833 := (n : @3) -> @829 @71 @15 @60 +@836 := @455 @204 @62 @727 +@837 := @743 @1 +@840 := @742 (@837 @202) @748 +@841 := @767 @1 +@851 := (hbind : @740) -> + (hF : @840) -> (hA : @813) -> (hne : @757) -> @760 (fun (ro : @759) => @766 (@841 @771 @220 @15)) +@861 := {A : @18} -> + {f : @3} -> + {fn : @412} -> + {args : @465} -> + {env : @696} -> {F : @161} -> {o : @672} -> (hB : @833) -> (hfn : @805) -> (hwt : @836) -> @851 +@862 := @828 @2 +@864 := @829 @2 @15 +@866 := (n : @3) -> @864 @60 +@867 := @461 @62 +@868 := @867 @727 +@877 := {f : @3} -> + {fn : @412} -> + {args : @465} -> + {env : @696} -> {F : @161} -> {o : @672} -> (hB : @866) -> (hfn : @805) -> (hwt : @868) -> @851 +@878 := @862 @402 +@880 := (n : @3) -> @864 @402 +@881 := @802 @402 +@882 := @706 @881 +@883 := @882 @720 +@884 := @837 @402 +@885 := @742 @884 +@886 := @885 @748 +@887 := @810 @402 +@889 := @887 @204 @62 +@891 := @841 (@770 @402) +@899 := (hF : @886) -> (hA : @889) -> (hne : @757) -> @760 (fun (ro : @759) => @766 (@891 @220 @15)) +@908 := {fn : @412} -> + {args : @465} -> + {env : @696} -> + {F : @161} -> {o : @672} -> (hB : @880) -> (hfn : @883) -> (hwt : @868) -> (hbind : @740) -> @899 +@909 := @878 @431 +@911 := @882 (@719 @431) +@912 := @726 @431 +@913 := @867 @912 +@915 := @731 (@732 @431) +@927 := {args : @465} -> + {env : @696} -> + {F : @161} -> + {o : @672} -> + (hB : @880) -> (hfn : @911) -> (hwt : @913) -> (hbind : @730 (@915 @60 @405) @739) -> @899 +@928 := @909 @392 +@930 := @605 (@547 @387) +@932 := @461 @930 @912 +@938 := @388 (@10 @204) (@388 (@170 @71) @387) +@942 := @730 (@915 @938 @405) @739 +@948 := @388 (@10 @211) (@388 (@170 @202) @387) +@950 := @887 @948 @62 +@952 := @388 (@10 @751) +@953 := #12 +@972 := {env : @696} -> + {F : @161} -> + {o : @672} -> + (hB : @880) -> + (hfn : @911) -> + (hwt : @932) -> + (hbind : @942) -> + (hF : @886) -> + (hA : @950) -> + (hne : @757) -> @760 (fun (ro : @759) => @766 (@891 (@952 (@388 (@170 @953) @387)) @15)) +@973 := @928 @410 +@975 := @619 (@561 @387) +@977 := @461 @975 @912 +@988 := @730 (@915 @930 @405) (@738 (@406 (@400 @546) (@406 (@403 @604) @405))) +@994 := @388 (@10 @202) (@388 (@170 @204) @387) +@1016 := {F : @161} -> + {o : @672} -> + (hB : @880) -> + (hfn : @911) -> + (hwt : @977) -> + (hbind : @988) -> + (hF : @886) -> + (hA : @887 @994 @62) -> + (hne : @757) -> + @760 (fun (ro : @759) => @766 (@891 (@388 (@10 @953) (@388 (@170 @220) @387)) @15)) +@1017 := @973 @411 +@1018 := @636 @912 +@1029 := @730 (@915 @975 @405) (@738 (@406 (@400 @560) (@406 (@403 @618) @405))) +@1031 := @885 (@747 @411) +@1033 := @887 @938 @62 +@1034 := @762 @411 +@1056 := {o : @672} -> + (hB : @880) -> + (hfn : @911) -> + (hwt : @1018) -> + (hbind : @1029) -> + (hF : @1031) -> + (hA : @1033) -> + (hne : @757) -> + @760 + (fun (ro : @759) => @761 (@1034 @204 @15) (@891 (@388 (@10 @220) (@388 (@170 @211) @387)) @15)) +@1057 := @1017 @660 +@1058 := @644 @912 +@1069 := @730 (@915 @635 @405) (@738 (@406 (@400 @543) (@406 (@403 @601) @405))) +@1070 := @887 @930 +@1072 := @658 @71 @60 +@1073 := @1070 @1072 +@1075 := @658 @204 @71 +@1094 := (hB : @880) -> + (hfn : @911) -> + (hwt : @1058) -> + (hbind : @1069) -> + (hF : @1031) -> + (hA : @1073) -> + (hne : @673 @1075 @678) -> + @760 (fun (ro : @759) => @761 (@1034 (@658 @211 @202) @15) (@891 @948 @15)) +@1095 := @1057 @435 +@1096 := @652 @912 +@1107 := @730 (@915 @643 @405) (@738 (@406 (@400 @557) (@406 (@403 @615) @405))) +@1108 := @887 @975 +@1110 := @658 @60 @62 +@1129 := (hfn : @911) -> + (hwt : @1096) -> + (hbind : @1107) -> + (hF : @1031) -> + (hA : @1108 @1110) -> + (hne : @673 @1072 @678) -> + @760 (fun (ro : @759) => @761 (@1034 (@658 @202 @204) @15) (@891 @994 @15)) +@1130 := Eq.refl.{1} +@1133 := @1095 (@1130 @705 @881) +@1134 := @656 @912 +@1145 := @730 (@915 @651 @405) (@738 (@406 (@400 @572) (@406 (@403 @630) @405))) +@1146 := @887 @635 +@1148 := @658 @62 @64 +@1164 := (hwt : @1134) -> + (hbind : @1145) -> + (hF : @1031) -> + (hA : @1146 @1148) -> + (hne : @673 @1110 @678) -> @760 (fun (ro : @759) => @761 (@1034 @1075 @15) (@891 @938 @15)) +@1165 := @1133 @655 +@1167 := @915 @392 @405 +@1170 := @730 @1167 (@738 @410) +@1171 := @887 @643 +@1173 := @658 @64 @20 +@1188 := (hbind : @1170) -> + (hF : @1031) -> + (hA : @1171 @1173) -> + (hne : @673 @1148 @678) -> @760 (fun (ro : @759) => @761 (@1034 @1072 @15) (@891 @930 @15)) +@1191 := @1165 (@1130 @729 @1167) +@1192 := @887 @651 +@1194 := @658 @20 @6 +@1208 := (hF : @1031) -> + (hA : @1192 @1194) -> + (hne : @673 @1173 @678) -> @760 (fun (ro : @759) => @761 (@1034 @1110 @15) (@891 @975 @15)) +@1211 := @1191 (@1130 @741 @884) +@1225 := (hA : @887 @392 @660) -> + (hne : @673 @1194 @678) -> @760 (fun (ro : @759) => @761 (@1034 @1148 @15) (@891 @635 @15)) +@1226 := @1211 @670 +@1237 := (hne : @673 @660 @678) -> @760 (fun (ro : @759) => @761 (@1034 @1173 @15) (@891 @643 @15)) +@1238 := @1226 @691 +@1244 := @761 (@1034 @1194 @15) (@891 @651 @15) +@1246 := @760 (fun (ro : @759) => @1244) +@1248 := @760 (fun (__e_ro : @759) => @1244) +@1249 := LexLeanPreservation.Rust.RepresentableL +@1250 := @10 @23 +@1252 := @388 @359 @387 +@1255 := @1249 (@388 @1250 @1252) +@1256 := (__e_hrep : @1255) -> @1248 +@1257 := fun (__e_hrep : @1255) => @1238 +@1258 := (r : @164) -> @1256 +@1259 := fun (r : @164) => @1257 +@1260 := (v : @5) -> @1258 +@1261 := fun (v : @5) => @1259 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustCore.lean deleted file mode 100644 index fbe1bdcec..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (n : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat n) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustCore.lex.tex new file mode 100644 index 000000000..78510e028 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustCore.lex.tex @@ -0,0 +1,424 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore.root : @844 := @845 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore.flags +@3 := Nat +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@59 := Prod.{0, 0} @3 @50 +@60 := 0 +@64 := Prod.mk.{0, 0} @3 @50 @60 +@65 := @64 @6 +@66 := @51 @59 +@67 := @52 @59 +@69 := @67 @65 @66 +@70 := Bool.true +@71 := LexLeanTarget.TargetSyntax.Function +@72 := LexLeanTarget.TargetSyntax.Program.functions +@73 := @72 @0 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := @51 @3 +@76 := @51 @74 +@77 := LexLeanTarget.TargetSyntax.Ty.unit +@78 := LexLeanTarget.TargetSyntax.Value.unit +@81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 +@86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 +@91 := List.getD.{0} @71 @73 @60 @86 +@95 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore.root @17 @60 +@96 := LexLeanPreservation.Rust.WTL +@104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 +@106 := LexLeanPreservation.Rust.wtl_nil @0 +@107 := @96 @0 +@113 := {c : @9} -> {A : @10} -> @107 @4 @17 @53 @76 +@114 := @106 @1 +@115 := @107 @1 +@119 := {A : @10} -> @115 @17 @53 @76 +@120 := @114 @2 +@121 := @115 @2 +@122 := @121 @53 +@123 := @122 @76 +@124 := List.{0} +@125 := @124 @50 +@126 := @124 @74 +@127 := #6 +@128 := @11 @127 +@129 := #5 +@130 := @128 @129 +@131 := #4 +@134 := @130 @131 @12 @14 +@135 := #7 +@140 := @96 @135 @127 @129 @14 @4 +@141 := #8 +@144 := @96 @141 @135 @127 +@146 := @54 @129 @12 +@147 := @144 @146 +@148 := @52 @74 +@150 := @148 @131 @14 +@160 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @134) -> (hs : @140) -> @147 @150 +@162 := LexLeanPreservation.Rust.wtl_cons @0 +@182 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> + (h : @27 @129 @131 @12 @14) -> (hs : @107 @127 @129 @14 @4) -> @107 @135 @127 @146 @150 +@183 := @162 @1 +@199 := {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> (h : @36 @131 @12 @14) -> (hs : @115 @129 @14 @4) -> @115 @127 @146 @150 +@200 := @183 @2 +@202 := @43 @12 @14 +@204 := @121 @14 @4 +@212 := {v : @50} -> + {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @202) -> (hs : @204) -> @121 @146 @150 +@213 := @200 @6 +@214 := @5 @131 +@216 := @43 @214 @14 +@217 := @5 @127 +@218 := @54 @217 +@226 := {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @216) -> (hs : @204) -> @121 (@218 @12) @150 +@227 := @213 @7 +@228 := @5 @12 +@230 := @43 @228 @7 +@231 := @5 @129 +@232 := @54 @231 +@234 := @121 (@232 @12) +@235 := @148 @7 +@236 := @235 @14 +@241 := {vs : @125} -> {ts : @126} -> (h : @230) -> (hs : @204) -> @234 @236 +@242 := @227 @53 +@243 := @5 @14 +@245 := @43 @243 @7 +@246 := @122 @4 +@248 := @54 @214 @53 +@249 := @121 @248 +@253 := {ts : @126} -> (h : @245) -> (hs : @246) -> @249 @236 +@254 := @242 @76 +@256 := @54 @228 @53 +@257 := @121 @256 +@258 := @235 @76 +@261 := (h : @49) -> (hs : @123) -> @257 @258 +@262 := @254 @47 +@264 := @54 @243 @53 +@265 := @121 @264 +@267 := (hs : @123) -> @265 @258 +@268 := @262 @120 +@269 := @121 @56 +@270 := @269 @258 +@271 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.denote +@272 := @271 @4 +@273 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.__fits_0 +@274 := @273 @4 +@276 := Coverage.Main.builders @4 +@277 := Option.{0} +@278 := @277 @3 +@279 := Unit +@282 := Except.{0, 0} @279 @3 +@285 := LexLeanPreservation.encOption @3 @5 +@286 := LexLeanPreservation.encUnit +@291 := LexLeanPreservation.encExcept @279 @3 @286 @5 +@297 := LexLeanPreservation.encPair @278 @282 @285 @291 @276 +@299 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.root @4 +@300 := Bool +@301 := Ne.{1} +@302 := LexLeanPreservation.Obs +@303 := @301 @302 +@304 := LexLeanPreservation.Rel +@307 := @303 (@304 @4 @17) +@308 := LexLeanPreservation.Obs.stuck +@311 := (f : @300) -> (v : @50) -> @307 @308 +@313 := LexLeanPreservation.Rust.rel_ne_stuck @274 +@319 := (v : @50) -> @303 (@304 (@273 @14) @17) @308 +@320 := @313 @297 +@324 := @303 (@304 @274 @297) @308 +@325 := @124 @59 +@326 := LexLeanPreservation.Rust.FunSem +@327 := #9 +@333 := (n : @3) -> @326 @327 @141 @135 @17 @127 +@334 := Eq.{1} +@335 := @277 @71 +@336 := @334 @335 +@343 := LexLeanRuntime.index (@124 @71) @71 (LexLeanRuntime.instIndexableList @71) +@347 := @336 (@343 (@72 @327) @127) +@348 := Option.some.{0} +@349 := @348 @71 +@350 := @349 @129 +@351 := @347 @350 +@352 := #10 +@356 := @96 @352 @327 @141 @129 +@357 := LexLeanTarget.TargetSyntax.Function.types +@358 := @357 @127 +@359 := @356 @358 +@360 := @277 @325 +@361 := @334 @360 +@362 := LexLeanTarget.TargetSemantics.bindAll +@363 := LexLeanTarget.TargetSyntax.Function.parameters +@368 := @361 (@362 (@363 @135) @127 @66) +@369 := @348 @325 +@370 := @369 @129 +@371 := @368 @370 +@372 := @277 @300 +@373 := @334 @372 +@374 := LexLeanPreservation.Rust.fnFallible +@375 := #11 +@378 := @373 (@374 @375 @327) +@379 := @348 @300 +@380 := @379 @129 +@381 := @378 @380 +@382 := LexLeanPreservation.RunConv +@383 := #13 +@387 := @382 @383 @352 @141 @129 +@389 := @303 @127 @308 +@390 := Exists.{1} +@391 := LexLeanPreservation.Rust.ROut +@392 := @390 @391 +@393 := And +@394 := LexLeanPreservation.Rust.RealizesFn +@398 := @393 (@394 @327 @141 @17) +@399 := LexLeanPreservation.Rust.RCI +@401 := @399 #15 +@402 := LexLeanPreservation.Rust.fnIdent +@403 := @402 @383 +@410 := (hne : @389) -> @392 (fun (ro : @391) => @398 (@401 @403 @375 @17)) +@425 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @325} -> + {F : @300} -> + {o : @302} -> + (hB : @333) -> + (hfn : @351) -> (hwt : @359) -> (hbind : @371) -> (hF : @381) -> (hA : @387) -> @410 +@427 := LexLeanPreservation.Rust.compose @0 +@428 := @326 @0 +@433 := (n : @3) -> @428 @141 @135 @17 @127 +@434 := @343 @73 +@437 := @336 (@434 @127) @350 +@441 := @107 @327 @141 @129 @358 +@442 := @382 @0 +@445 := @442 @352 @141 @129 +@459 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @325} -> + {F : @300} -> + {o : @302} -> + (hB : @433) -> + (hfn : @437) -> (hwt : @441) -> (hbind : @371) -> (hF : @381) -> (hA : @445) -> @410 +@460 := @427 @1 +@461 := @428 @1 +@465 := (n : @3) -> @461 @135 @17 @127 +@468 := @115 @141 @129 @358 +@469 := @374 @1 +@472 := @373 (@469 @327) @380 +@473 := @399 @1 +@483 := (hbind : @371) -> + (hF : @472) -> (hA : @445) -> (hne : @389) -> @392 (fun (ro : @391) => @398 (@473 @403 @375 @17)) +@493 := {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @325} -> {F : @300} -> {o : @302} -> (hB : @465) -> (hfn : @437) -> (hwt : @468) -> @483 +@494 := @460 @2 +@496 := @461 @2 @17 +@498 := (n : @3) -> @496 @127 +@499 := @121 @129 +@500 := @499 @358 +@509 := {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @325} -> {F : @300} -> {o : @302} -> (hB : @498) -> (hfn : @437) -> (hwt : @500) -> @483 +@510 := @494 @60 +@512 := (n : @3) -> @496 @60 +@513 := @434 @60 +@514 := @336 @513 +@515 := @514 @350 +@516 := @469 @60 +@517 := @373 @516 +@518 := @517 @380 +@519 := @442 @60 +@521 := @519 @141 @129 +@523 := @473 (@402 @60) +@531 := (hF : @518) -> (hA : @521) -> (hne : @389) -> @392 (fun (ro : @391) => @398 (@523 @375 @17)) +@540 := {fn : @71} -> + {args : @125} -> + {env : @325} -> + {F : @300} -> {o : @302} -> (hB : @512) -> (hfn : @515) -> (hwt : @500) -> (hbind : @371) -> @531 +@541 := @510 @91 +@543 := @514 (@349 @91) +@544 := @357 @91 +@545 := @499 @544 +@547 := @362 (@363 @91) +@559 := {args : @125} -> + {env : @325} -> + {F : @300} -> + {o : @302} -> + (hB : @512) -> (hfn : @543) -> (hwt : @545) -> (hbind : @361 (@547 @127 @66) @370) -> @531 +@560 := @541 @56 +@561 := @218 @53 +@563 := @121 @561 @544 +@566 := @54 (@5 @135) @53 +@570 := @361 (@547 @566 @66) @370 +@573 := @54 (@5 @327) @53 +@594 := {env : @325} -> + {F : @300} -> + {o : @302} -> + (hB : @512) -> + (hfn : @543) -> + (hwt : @563) -> + (hbind : @570) -> + (hF : @518) -> + (hA : @519 @573 @129) -> + (hne : @389) -> @392 (fun (ro : @391) => @398 (@523 (@54 (@5 #12) @53) @17)) +@595 := @560 @69 +@596 := @232 @53 +@598 := @121 @596 @544 +@606 := @361 (@547 @561 @66) (@369 (@67 (@64 @217) @66)) +@609 := @54 (@5 @141) @53 +@628 := {F : @300} -> + {o : @302} -> + (hB : @512) -> + (hfn : @543) -> + (hwt : @598) -> + (hbind : @606) -> + (hF : @518) -> + (hA : @519 @609 @129) -> + (hne : @389) -> @392 (fun (ro : @391) => @398 (@523 (@54 (@5 @375) @53) @17)) +@629 := @595 @70 +@630 := @249 @544 +@638 := @361 (@547 @596 @66) (@369 (@67 (@64 @231) @66)) +@640 := @517 (@379 @70) +@642 := @519 @566 @129 +@643 := @394 @70 +@662 := {o : @302} -> + (hB : @512) -> + (hfn : @543) -> + (hwt : @630) -> + (hbind : @638) -> + (hF : @640) -> + (hA : @642) -> + (hne : @389) -> @392 (fun (ro : @391) => @393 (@643 @141 @17) (@523 (@54 (@5 @352) @53) @17)) +@663 := @629 @272 +@664 := @257 @544 +@672 := @361 (@547 @248 @66) (@369 (@67 (@64 @214) @66)) +@673 := @519 @561 +@674 := @271 @127 +@675 := @673 @674 +@676 := @271 @135 +@694 := (hB : @512) -> + (hfn : @543) -> + (hwt : @664) -> + (hbind : @672) -> + (hF : @640) -> + (hA : @675) -> + (hne : @303 @676 @308) -> @392 (fun (ro : @391) => @393 (@643 (@271 @327) @17) (@523 @573 @17)) +@695 := @663 @95 +@696 := @265 @544 +@704 := @361 (@547 @256 @66) (@369 (@67 (@64 @228) @66)) +@705 := @519 @596 +@706 := @271 @129 +@724 := (hfn : @543) -> + (hwt : @696) -> + (hbind : @704) -> + (hF : @640) -> + (hA : @705 @706) -> + (hne : @303 @674 @308) -> @392 (fun (ro : @391) => @393 (@643 (@271 @141) @17) (@523 @609 @17)) +@725 := Eq.refl.{1} +@728 := @695 (@725 @335 @513) +@729 := @269 @544 +@737 := @361 (@547 @264 @66) (@369 (@67 (@64 @243) @66)) +@738 := @519 @248 +@739 := @271 @131 +@755 := (hwt : @729) -> + (hbind : @737) -> + (hF : @640) -> + (hA : @738 @739) -> + (hne : @303 @706 @308) -> @392 (fun (ro : @391) => @393 (@643 @676 @17) (@523 @566 @17)) +@756 := @728 @268 +@758 := @547 @56 @66 +@761 := @361 @758 (@369 @69) +@762 := @519 @256 +@763 := @271 @12 +@778 := (hbind : @761) -> + (hF : @640) -> + (hA : @762 @763) -> + (hne : @303 @739 @308) -> @392 (fun (ro : @391) => @393 (@643 @674 @17) (@523 @561 @17)) +@781 := @756 (@725 @360 @758) +@782 := @519 @264 +@783 := @271 @14 +@797 := (hF : @640) -> + (hA : @782 @783) -> + (hne : @303 @763 @308) -> @392 (fun (ro : @391) => @393 (@643 @706 @17) (@523 @596 @17)) +@800 := @781 (@725 @372 @516) +@814 := (hA : @519 @56 @272) -> + (hne : @303 @783 @308) -> @392 (fun (ro : @391) => @393 (@643 @739 @17) (@523 @248 @17)) +@815 := @800 @299 +@826 := (hne : @303 @272 @308) -> @392 (fun (ro : @391) => @393 (@643 @763 @17) (@523 @256 @17)) +@827 := @815 @320 +@833 := @393 (@643 @783 @17) (@523 @264 @17) +@835 := @392 (fun (ro : @391) => @833) +@837 := @392 (fun (__e_ro : @391) => @833) +@841 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@842 := (__e_hrep : @841) -> @837 +@843 := fun (__e_hrep : @841) => @827 +@844 := (n : @3) -> @842 +@845 := fun (n : @3) => @843 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustStd.lean deleted file mode 100644 index 282b61257..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (n : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat n) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustStd.lex.tex new file mode 100644 index 000000000..ad123590b --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustStd.lex.tex @@ -0,0 +1,424 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd.root : @844 := @845 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd.flags +@3 := Nat +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@59 := Prod.{0, 0} @3 @50 +@60 := 0 +@64 := Prod.mk.{0, 0} @3 @50 @60 +@65 := @64 @6 +@66 := @51 @59 +@67 := @52 @59 +@69 := @67 @65 @66 +@70 := Bool.true +@71 := LexLeanTarget.TargetSyntax.Function +@72 := LexLeanTarget.TargetSyntax.Program.functions +@73 := @72 @0 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := @51 @3 +@76 := @51 @74 +@77 := LexLeanTarget.TargetSyntax.Ty.unit +@78 := LexLeanTarget.TargetSyntax.Value.unit +@81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 +@86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 +@91 := List.getD.{0} @71 @73 @60 @86 +@95 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd.root @17 @60 +@96 := LexLeanPreservation.Rust.WTL +@104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 +@106 := LexLeanPreservation.Rust.wtl_nil @0 +@107 := @96 @0 +@113 := {c : @9} -> {A : @10} -> @107 @4 @17 @53 @76 +@114 := @106 @1 +@115 := @107 @1 +@119 := {A : @10} -> @115 @17 @53 @76 +@120 := @114 @2 +@121 := @115 @2 +@122 := @121 @53 +@123 := @122 @76 +@124 := List.{0} +@125 := @124 @50 +@126 := @124 @74 +@127 := #6 +@128 := @11 @127 +@129 := #5 +@130 := @128 @129 +@131 := #4 +@134 := @130 @131 @12 @14 +@135 := #7 +@140 := @96 @135 @127 @129 @14 @4 +@141 := #8 +@144 := @96 @141 @135 @127 +@146 := @54 @129 @12 +@147 := @144 @146 +@148 := @52 @74 +@150 := @148 @131 @14 +@160 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @134) -> (hs : @140) -> @147 @150 +@162 := LexLeanPreservation.Rust.wtl_cons @0 +@182 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> + (h : @27 @129 @131 @12 @14) -> (hs : @107 @127 @129 @14 @4) -> @107 @135 @127 @146 @150 +@183 := @162 @1 +@199 := {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> (h : @36 @131 @12 @14) -> (hs : @115 @129 @14 @4) -> @115 @127 @146 @150 +@200 := @183 @2 +@202 := @43 @12 @14 +@204 := @121 @14 @4 +@212 := {v : @50} -> + {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @202) -> (hs : @204) -> @121 @146 @150 +@213 := @200 @6 +@214 := @5 @131 +@216 := @43 @214 @14 +@217 := @5 @127 +@218 := @54 @217 +@226 := {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @216) -> (hs : @204) -> @121 (@218 @12) @150 +@227 := @213 @7 +@228 := @5 @12 +@230 := @43 @228 @7 +@231 := @5 @129 +@232 := @54 @231 +@234 := @121 (@232 @12) +@235 := @148 @7 +@236 := @235 @14 +@241 := {vs : @125} -> {ts : @126} -> (h : @230) -> (hs : @204) -> @234 @236 +@242 := @227 @53 +@243 := @5 @14 +@245 := @43 @243 @7 +@246 := @122 @4 +@248 := @54 @214 @53 +@249 := @121 @248 +@253 := {ts : @126} -> (h : @245) -> (hs : @246) -> @249 @236 +@254 := @242 @76 +@256 := @54 @228 @53 +@257 := @121 @256 +@258 := @235 @76 +@261 := (h : @49) -> (hs : @123) -> @257 @258 +@262 := @254 @47 +@264 := @54 @243 @53 +@265 := @121 @264 +@267 := (hs : @123) -> @265 @258 +@268 := @262 @120 +@269 := @121 @56 +@270 := @269 @258 +@271 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.denote +@272 := @271 @4 +@273 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.__fits_0 +@274 := @273 @4 +@276 := Coverage.Main.builders @4 +@277 := Option.{0} +@278 := @277 @3 +@279 := Unit +@282 := Except.{0, 0} @279 @3 +@285 := LexLeanPreservation.encOption @3 @5 +@286 := LexLeanPreservation.encUnit +@291 := LexLeanPreservation.encExcept @279 @3 @286 @5 +@297 := LexLeanPreservation.encPair @278 @282 @285 @291 @276 +@299 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.root @4 +@300 := Bool +@301 := Ne.{1} +@302 := LexLeanPreservation.Obs +@303 := @301 @302 +@304 := LexLeanPreservation.Rel +@307 := @303 (@304 @4 @17) +@308 := LexLeanPreservation.Obs.stuck +@311 := (f : @300) -> (v : @50) -> @307 @308 +@313 := LexLeanPreservation.Rust.rel_ne_stuck @274 +@319 := (v : @50) -> @303 (@304 (@273 @14) @17) @308 +@320 := @313 @297 +@324 := @303 (@304 @274 @297) @308 +@325 := @124 @59 +@326 := LexLeanPreservation.Rust.FunSem +@327 := #9 +@333 := (n : @3) -> @326 @327 @141 @135 @17 @127 +@334 := Eq.{1} +@335 := @277 @71 +@336 := @334 @335 +@343 := LexLeanRuntime.index (@124 @71) @71 (LexLeanRuntime.instIndexableList @71) +@347 := @336 (@343 (@72 @327) @127) +@348 := Option.some.{0} +@349 := @348 @71 +@350 := @349 @129 +@351 := @347 @350 +@352 := #10 +@356 := @96 @352 @327 @141 @129 +@357 := LexLeanTarget.TargetSyntax.Function.types +@358 := @357 @127 +@359 := @356 @358 +@360 := @277 @325 +@361 := @334 @360 +@362 := LexLeanTarget.TargetSemantics.bindAll +@363 := LexLeanTarget.TargetSyntax.Function.parameters +@368 := @361 (@362 (@363 @135) @127 @66) +@369 := @348 @325 +@370 := @369 @129 +@371 := @368 @370 +@372 := @277 @300 +@373 := @334 @372 +@374 := LexLeanPreservation.Rust.fnFallible +@375 := #11 +@378 := @373 (@374 @375 @327) +@379 := @348 @300 +@380 := @379 @129 +@381 := @378 @380 +@382 := LexLeanPreservation.RunConv +@383 := #13 +@387 := @382 @383 @352 @141 @129 +@389 := @303 @127 @308 +@390 := Exists.{1} +@391 := LexLeanPreservation.Rust.ROut +@392 := @390 @391 +@393 := And +@394 := LexLeanPreservation.Rust.RealizesFn +@398 := @393 (@394 @327 @141 @17) +@399 := LexLeanPreservation.Rust.RCI +@401 := @399 #15 +@402 := LexLeanPreservation.Rust.fnIdent +@403 := @402 @383 +@410 := (hne : @389) -> @392 (fun (ro : @391) => @398 (@401 @403 @375 @17)) +@425 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @325} -> + {F : @300} -> + {o : @302} -> + (hB : @333) -> + (hfn : @351) -> (hwt : @359) -> (hbind : @371) -> (hF : @381) -> (hA : @387) -> @410 +@427 := LexLeanPreservation.Rust.compose @0 +@428 := @326 @0 +@433 := (n : @3) -> @428 @141 @135 @17 @127 +@434 := @343 @73 +@437 := @336 (@434 @127) @350 +@441 := @107 @327 @141 @129 @358 +@442 := @382 @0 +@445 := @442 @352 @141 @129 +@459 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @325} -> + {F : @300} -> + {o : @302} -> + (hB : @433) -> + (hfn : @437) -> (hwt : @441) -> (hbind : @371) -> (hF : @381) -> (hA : @445) -> @410 +@460 := @427 @1 +@461 := @428 @1 +@465 := (n : @3) -> @461 @135 @17 @127 +@468 := @115 @141 @129 @358 +@469 := @374 @1 +@472 := @373 (@469 @327) @380 +@473 := @399 @1 +@483 := (hbind : @371) -> + (hF : @472) -> (hA : @445) -> (hne : @389) -> @392 (fun (ro : @391) => @398 (@473 @403 @375 @17)) +@493 := {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @325} -> {F : @300} -> {o : @302} -> (hB : @465) -> (hfn : @437) -> (hwt : @468) -> @483 +@494 := @460 @2 +@496 := @461 @2 @17 +@498 := (n : @3) -> @496 @127 +@499 := @121 @129 +@500 := @499 @358 +@509 := {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @325} -> {F : @300} -> {o : @302} -> (hB : @498) -> (hfn : @437) -> (hwt : @500) -> @483 +@510 := @494 @60 +@512 := (n : @3) -> @496 @60 +@513 := @434 @60 +@514 := @336 @513 +@515 := @514 @350 +@516 := @469 @60 +@517 := @373 @516 +@518 := @517 @380 +@519 := @442 @60 +@521 := @519 @141 @129 +@523 := @473 (@402 @60) +@531 := (hF : @518) -> (hA : @521) -> (hne : @389) -> @392 (fun (ro : @391) => @398 (@523 @375 @17)) +@540 := {fn : @71} -> + {args : @125} -> + {env : @325} -> + {F : @300} -> {o : @302} -> (hB : @512) -> (hfn : @515) -> (hwt : @500) -> (hbind : @371) -> @531 +@541 := @510 @91 +@543 := @514 (@349 @91) +@544 := @357 @91 +@545 := @499 @544 +@547 := @362 (@363 @91) +@559 := {args : @125} -> + {env : @325} -> + {F : @300} -> + {o : @302} -> + (hB : @512) -> (hfn : @543) -> (hwt : @545) -> (hbind : @361 (@547 @127 @66) @370) -> @531 +@560 := @541 @56 +@561 := @218 @53 +@563 := @121 @561 @544 +@566 := @54 (@5 @135) @53 +@570 := @361 (@547 @566 @66) @370 +@573 := @54 (@5 @327) @53 +@594 := {env : @325} -> + {F : @300} -> + {o : @302} -> + (hB : @512) -> + (hfn : @543) -> + (hwt : @563) -> + (hbind : @570) -> + (hF : @518) -> + (hA : @519 @573 @129) -> + (hne : @389) -> @392 (fun (ro : @391) => @398 (@523 (@54 (@5 #12) @53) @17)) +@595 := @560 @69 +@596 := @232 @53 +@598 := @121 @596 @544 +@606 := @361 (@547 @561 @66) (@369 (@67 (@64 @217) @66)) +@609 := @54 (@5 @141) @53 +@628 := {F : @300} -> + {o : @302} -> + (hB : @512) -> + (hfn : @543) -> + (hwt : @598) -> + (hbind : @606) -> + (hF : @518) -> + (hA : @519 @609 @129) -> + (hne : @389) -> @392 (fun (ro : @391) => @398 (@523 (@54 (@5 @375) @53) @17)) +@629 := @595 @70 +@630 := @249 @544 +@638 := @361 (@547 @596 @66) (@369 (@67 (@64 @231) @66)) +@640 := @517 (@379 @70) +@642 := @519 @566 @129 +@643 := @394 @70 +@662 := {o : @302} -> + (hB : @512) -> + (hfn : @543) -> + (hwt : @630) -> + (hbind : @638) -> + (hF : @640) -> + (hA : @642) -> + (hne : @389) -> @392 (fun (ro : @391) => @393 (@643 @141 @17) (@523 (@54 (@5 @352) @53) @17)) +@663 := @629 @272 +@664 := @257 @544 +@672 := @361 (@547 @248 @66) (@369 (@67 (@64 @214) @66)) +@673 := @519 @561 +@674 := @271 @127 +@675 := @673 @674 +@676 := @271 @135 +@694 := (hB : @512) -> + (hfn : @543) -> + (hwt : @664) -> + (hbind : @672) -> + (hF : @640) -> + (hA : @675) -> + (hne : @303 @676 @308) -> @392 (fun (ro : @391) => @393 (@643 (@271 @327) @17) (@523 @573 @17)) +@695 := @663 @95 +@696 := @265 @544 +@704 := @361 (@547 @256 @66) (@369 (@67 (@64 @228) @66)) +@705 := @519 @596 +@706 := @271 @129 +@724 := (hfn : @543) -> + (hwt : @696) -> + (hbind : @704) -> + (hF : @640) -> + (hA : @705 @706) -> + (hne : @303 @674 @308) -> @392 (fun (ro : @391) => @393 (@643 (@271 @141) @17) (@523 @609 @17)) +@725 := Eq.refl.{1} +@728 := @695 (@725 @335 @513) +@729 := @269 @544 +@737 := @361 (@547 @264 @66) (@369 (@67 (@64 @243) @66)) +@738 := @519 @248 +@739 := @271 @131 +@755 := (hwt : @729) -> + (hbind : @737) -> + (hF : @640) -> + (hA : @738 @739) -> + (hne : @303 @706 @308) -> @392 (fun (ro : @391) => @393 (@643 @676 @17) (@523 @566 @17)) +@756 := @728 @268 +@758 := @547 @56 @66 +@761 := @361 @758 (@369 @69) +@762 := @519 @256 +@763 := @271 @12 +@778 := (hbind : @761) -> + (hF : @640) -> + (hA : @762 @763) -> + (hne : @303 @739 @308) -> @392 (fun (ro : @391) => @393 (@643 @674 @17) (@523 @561 @17)) +@781 := @756 (@725 @360 @758) +@782 := @519 @264 +@783 := @271 @14 +@797 := (hF : @640) -> + (hA : @782 @783) -> + (hne : @303 @763 @308) -> @392 (fun (ro : @391) => @393 (@643 @706 @17) (@523 @596 @17)) +@800 := @781 (@725 @372 @516) +@814 := (hA : @519 @56 @272) -> + (hne : @303 @783 @308) -> @392 (fun (ro : @391) => @393 (@643 @739 @17) (@523 @248 @17)) +@815 := @800 @299 +@826 := (hne : @303 @272 @308) -> @392 (fun (ro : @391) => @393 (@643 @763 @17) (@523 @256 @17)) +@827 := @815 @320 +@833 := @393 (@643 @783 @17) (@523 @264 @17) +@835 := @392 (fun (ro : @391) => @833) +@837 := @392 (fun (__e_ro : @391) => @833) +@841 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@842 := (__e_hrep : @841) -> @837 +@843 := fun (__e_hrep : @841) => @827 +@844 := (n : @3) -> @842 +@845 := fun (n : @3) => @843 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustCore.lean deleted file mode 100644 index 44b231383..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (p : (Prod Nat Bool)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool) p)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.denote p) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool) p)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_bool) p) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.root p) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustCore.lex.tex new file mode 100644 index 000000000..b4135b717 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustCore.lex.tex @@ -0,0 +1,521 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore.root : @1045 := @1046 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore.flags +@3 := Nat +@4 := Bool +@5 := Prod.{0, 0} +@6 := @5 @3 +@7 := @6 @4 +@8 := #1 +@9 := LexLeanTarget.TargetSyntax.Value.nat +@10 := LexLeanTarget.TargetSyntax.Value.bool +@11 := LexLeanPreservation.encPair +@12 := @11 @3 +@13 := @12 @4 +@14 := @13 @9 +@15 := @14 @10 +@16 := @15 @8 +@17 := LexLeanTarget.TargetSyntax.Ty.nat +@18 := LexLeanTarget.TargetSyntax.Ty.bool +@19 := LexLeanTarget.TargetSyntax.Ty.pair +@20 := @19 @17 +@21 := @20 @18 +@22 := #0 +@23 := LexLeanTarget.TargetSyntax.Program +@24 := LexLeanPreservation.Rust.RCrate +@25 := LexLeanPreservation.Rust.Flags +@26 := LexLeanPreservation.Rust.WT +@27 := #3 +@28 := @26 @27 +@29 := #2 +@31 := @28 @29 @8 +@32 := @9 @22 +@38 := {p : @23} -> {c : @24} -> {A : @25} -> (n : @3) -> @31 @32 @17 +@40 := LexLeanPreservation.Rust.wt_nat @0 +@41 := @26 @0 +@43 := @41 @29 @8 +@48 := {c : @24} -> {A : @25} -> (n : @3) -> @43 @32 @17 +@49 := @40 @1 +@50 := @41 @1 +@51 := @50 @8 +@55 := {A : @25} -> (n : @3) -> @51 @32 @17 +@56 := @49 @2 +@57 := @50 @2 +@58 := @57 @32 +@59 := @58 @17 +@60 := (n : @3) -> @59 +@62 := fun (__x : @3) => @56 @22 +@63 := @10 @22 +@69 := {p : @23} -> {c : @24} -> {A : @25} -> (b : @4) -> @31 @63 @18 +@71 := LexLeanPreservation.Rust.wt_bool @0 +@76 := {c : @24} -> {A : @25} -> (b : @4) -> @43 @63 @18 +@77 := @71 @1 +@81 := {A : @25} -> (b : @4) -> @51 @63 @18 +@82 := @77 @2 +@83 := @57 @63 +@84 := @83 @18 +@85 := (b : @4) -> @84 +@87 := fun (__x : @4) => @82 @22 +@88 := Sort 1 +@89 := LexLeanTarget.TargetSyntax.Value +@90 := (a._@._internal._hyg.#0 : @8) -> @89 +@91 := LexLeanTarget.TargetSyntax.Ty +@92 := #5 +@93 := #9 +@94 := @26 @93 +@95 := #8 +@96 := @94 @95 +@97 := #7 +@98 := @96 @97 +@99 := #4 +@100 := @99 @22 +@103 := (x : @92) -> @98 @100 @29 +@104 := #10 +@110 := (x : @92) -> @26 @104 @93 @95 @100 @29 +@111 := @5 @97 +@112 := #6 +@113 := @111 @112 +@114 := #11 +@117 := @26 @114 @104 @93 +@122 := @11 @95 @97 @112 @92 @22 +@123 := @117 @122 +@125 := @19 @99 @27 +@138 := {p : @23} -> + {c : @24} -> + {A : @25} -> + {α : @88} -> + {β : @88} -> + {ea : @90} -> + {eb : @90} -> {s : @91} -> {t : @91} -> (ha : @103) -> (hb : @110) -> (x : @113) -> @123 @125 +@140 := LexLeanPreservation.Rust.wt_encPair @0 +@165 := {c : @24} -> + {A : @25} -> + {α : @88} -> + {β : @88} -> + {ea : @90} -> + {eb : @90} -> + {s : @91} -> + {t : @91} -> + (ha : (x : @92) -> @41 @95 @97 @100 @29) -> + (hb : (x : @92) -> @41 @93 @95 @100 @29) -> (x : @113) -> @41 @104 @93 @122 @125 +@166 := @140 @1 +@187 := {A : @25} -> + {α : @88} -> + {β : @88} -> + {ea : @90} -> + {eb : @90} -> + {s : @91} -> + {t : @91} -> + (ha : (x : @92) -> @50 @97 @100 @29) -> + (hb : (x : @92) -> @50 @95 @100 @29) -> (x : @113) -> @50 @93 @122 @125 +@188 := @166 @2 +@190 := @57 @100 @29 +@191 := (x : @92) -> @190 +@202 := {α : @88} -> + {β : @88} -> + {ea : @90} -> + {eb : @90} -> {s : @91} -> {t : @91} -> (ha : @191) -> (hb : @191) -> (x : @113) -> @57 @122 @125 +@203 := @188 @3 +@204 := (a._@._internal._hyg.#0 : @3) -> @89 +@205 := (x : @3) -> @190 +@220 := {β : @88} -> + {ea : @204} -> + {eb : @90} -> + {s : @91} -> + {t : @91} -> (ha : @205) -> (hb : @191) -> (x : @6 @112) -> @57 (@12 @97 @112 @92 @22) @125 +@221 := @203 @4 +@222 := (a._@._internal._hyg.#0 : @4) -> @89 +@223 := (x : @4) -> @190 +@235 := {ea : @204} -> + {eb : @222} -> + {s : @91} -> {t : @91} -> (ha : @205) -> (hb : @223) -> (x : @7) -> @57 (@13 @112 @92 @22) @125 +@236 := @221 @9 +@238 := (x : @3) -> @58 @29 +@248 := {eb : @222} -> + {s : @91} -> {t : @91} -> (ha : @238) -> (hb : @223) -> (x : @7) -> @57 (@14 @92 @22) @125 +@249 := @236 @10 +@251 := (x : @4) -> @83 @29 +@252 := @15 @22 +@253 := @57 @252 +@259 := {s : @91} -> {t : @91} -> (ha : @238) -> (hb : @251) -> (x : @7) -> @253 @125 +@260 := @249 @17 +@261 := (x : @3) -> @59 +@267 := {t : @91} -> (ha : @261) -> (hb : @251) -> (x : @7) -> @253 (@20 @27) +@268 := @260 @18 +@273 := (ha : @261) -> (hb : (x : @4) -> @84) -> (x : @7) -> @253 @21 +@276 := @268 @62 @87 @8 +@278 := @57 @16 @21 +@279 := List.nil.{0} +@280 := List.cons.{0} +@281 := @279 @89 +@282 := @280 @89 +@284 := @282 @16 @281 +@285 := @6 @89 +@286 := 0 +@290 := Prod.mk.{0, 0} @3 @89 @286 +@291 := @290 @16 +@292 := @279 @285 +@293 := @280 @285 +@295 := @293 @291 @292 +@296 := Bool.false +@297 := LexLeanTarget.TargetSyntax.Function +@298 := LexLeanTarget.TargetSyntax.Program.functions +@299 := @298 @0 +@300 := @279 @3 +@301 := @279 @91 +@302 := LexLeanTarget.TargetSyntax.Ty.unit +@303 := LexLeanTarget.TargetSyntax.Value.unit +@306 := LexLeanTarget.TargetSyntax.Expr.value @302 @303 +@311 := LexLeanTarget.TargetSyntax.Function.mk @300 @301 @302 @306 +@316 := List.getD.{0} @297 @299 @286 @311 +@320 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore.root @22 @286 +@321 := LexLeanPreservation.Rust.WTL +@329 := {p : @23} -> {c : @24} -> {A : @25} -> @321 @29 @8 @22 @281 @301 +@331 := LexLeanPreservation.Rust.wtl_nil @0 +@332 := @321 @0 +@338 := {c : @24} -> {A : @25} -> @332 @8 @22 @281 @301 +@339 := @331 @1 +@340 := @332 @1 +@344 := {A : @25} -> @340 @22 @281 @301 +@345 := @339 @2 +@346 := @340 @2 +@347 := @346 @281 +@348 := @347 @301 +@349 := List.{0} +@350 := @349 @89 +@351 := @349 @91 +@356 := @26 @112 @92 @99 @27 @29 +@361 := @321 @97 @112 @92 @29 @8 +@364 := @321 @95 @97 @112 +@366 := @282 @92 @27 +@367 := @364 @366 +@368 := @280 @91 +@370 := @368 @99 @29 +@380 := {p : @23} -> + {c : @24} -> + {A : @25} -> + {v : @89} -> {t : @91} -> {vs : @350} -> {ts : @351} -> (h : @356) -> (hs : @361) -> @367 @370 +@382 := LexLeanPreservation.Rust.wtl_cons @0 +@402 := {c : @24} -> + {A : @25} -> + {v : @89} -> + {t : @91} -> + {vs : @350} -> + {ts : @351} -> (h : @41 @92 @99 @27 @29) -> (hs : @332 @112 @92 @29 @8) -> @332 @97 @112 @366 @370 +@403 := @382 @1 +@419 := {A : @25} -> + {v : @89} -> + {t : @91} -> + {vs : @350} -> + {ts : @351} -> (h : @50 @99 @27 @29) -> (hs : @340 @92 @29 @8) -> @340 @112 @366 @370 +@420 := @403 @2 +@422 := @57 @27 @29 +@424 := @346 @29 @8 +@432 := {v : @89} -> + {t : @91} -> {vs : @350} -> {ts : @351} -> (h : @422) -> (hs : @424) -> @346 @366 @370 +@433 := @420 @16 +@434 := @15 @99 +@436 := @57 @434 @29 +@437 := @15 @112 +@438 := @282 @437 +@446 := {t : @91} -> {vs : @350} -> {ts : @351} -> (h : @436) -> (hs : @424) -> @346 (@438 @27) @370 +@447 := @433 @21 +@448 := @15 @27 +@450 := @57 @448 @21 +@451 := @15 @92 +@452 := @282 @451 +@454 := @346 (@452 @27) +@455 := @368 @21 +@456 := @455 @29 +@461 := {vs : @350} -> {ts : @351} -> (h : @450) -> (hs : @424) -> @454 @456 +@462 := @447 @281 +@463 := @15 @29 +@465 := @57 @463 @21 +@466 := @347 @8 +@468 := @282 @434 @281 +@469 := @346 @468 +@473 := {ts : @351} -> (h : @465) -> (hs : @466) -> @469 @456 +@474 := @462 @301 +@476 := @282 @448 @281 +@477 := @346 @476 +@478 := @455 @301 +@481 := (h : @278) -> (hs : @348) -> @477 @478 +@482 := @474 @276 +@484 := @282 @463 @281 +@485 := @346 @484 +@487 := (hs : @348) -> @485 @478 +@488 := @482 @345 +@489 := @346 @284 +@490 := @489 @478 +@491 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.denote +@492 := @491 @8 +@493 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.__fits_0 +@494 := @493 @8 +@496 := Coverage.Main.pairs @8 +@501 := @11 @4 @3 @10 @9 @496 +@503 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.root @8 +@504 := Ne.{1} +@505 := LexLeanPreservation.Obs +@506 := @504 @505 +@507 := LexLeanPreservation.Rel +@510 := @506 (@507 @8 @22) +@511 := LexLeanPreservation.Obs.stuck +@514 := (f : @4) -> (v : @89) -> @510 @511 +@516 := LexLeanPreservation.Rust.rel_ne_stuck @494 +@522 := (v : @89) -> @506 (@507 (@493 @29) @22) @511 +@523 := @516 @501 +@527 := @506 (@507 @494 @501) @511 +@528 := @349 @285 +@529 := LexLeanPreservation.Rust.FunSem +@535 := (n : @3) -> @529 @93 @95 @97 @22 @112 +@536 := Eq.{1} +@537 := Option.{0} +@538 := @537 @297 +@539 := @536 @538 +@546 := LexLeanRuntime.index (@349 @297) @297 (LexLeanRuntime.instIndexableList @297) +@550 := @539 (@546 (@298 @93) @112) +@551 := Option.some.{0} +@552 := @551 @297 +@553 := @552 @92 +@554 := @550 @553 +@558 := @321 @104 @93 @95 @92 +@559 := LexLeanTarget.TargetSyntax.Function.types +@560 := @559 @112 +@561 := @558 @560 +@562 := @537 @528 +@563 := @536 @562 +@564 := LexLeanTarget.TargetSemantics.bindAll +@565 := LexLeanTarget.TargetSyntax.Function.parameters +@570 := @563 (@564 (@565 @97) @112 @292) +@571 := @551 @528 +@572 := @571 @92 +@573 := @570 @572 +@574 := @537 @4 +@575 := @536 @574 +@576 := LexLeanPreservation.Rust.fnFallible +@579 := @575 (@576 @114 @93) +@580 := @551 @4 +@581 := @580 @92 +@582 := @579 @581 +@583 := LexLeanPreservation.RunConv +@584 := #13 +@588 := @583 @584 @104 @95 @92 +@590 := @506 @112 @511 +@591 := Exists.{1} +@592 := LexLeanPreservation.Rust.ROut +@593 := @591 @592 +@594 := And +@595 := LexLeanPreservation.Rust.RealizesFn +@599 := @594 (@595 @93 @95 @22) +@600 := LexLeanPreservation.Rust.RCI +@602 := @600 #15 +@603 := LexLeanPreservation.Rust.fnIdent +@604 := @603 @584 +@611 := (hne : @590) -> @593 (fun (ro : @592) => @599 (@602 @604 @114 @22)) +@626 := {p : @23} -> + {c : @24} -> + {A : @25} -> + {f : @3} -> + {fn : @297} -> + {args : @350} -> + {env : @528} -> + {F : @4} -> + {o : @505} -> + (hB : @535) -> + (hfn : @554) -> (hwt : @561) -> (hbind : @573) -> (hF : @582) -> (hA : @588) -> @611 +@628 := LexLeanPreservation.Rust.compose @0 +@629 := @529 @0 +@634 := (n : @3) -> @629 @95 @97 @22 @112 +@635 := @546 @299 +@638 := @539 (@635 @112) @553 +@642 := @332 @93 @95 @92 @560 +@643 := @583 @0 +@646 := @643 @104 @95 @92 +@660 := {c : @24} -> + {A : @25} -> + {f : @3} -> + {fn : @297} -> + {args : @350} -> + {env : @528} -> + {F : @4} -> + {o : @505} -> + (hB : @634) -> + (hfn : @638) -> (hwt : @642) -> (hbind : @573) -> (hF : @582) -> (hA : @646) -> @611 +@661 := @628 @1 +@662 := @629 @1 +@666 := (n : @3) -> @662 @97 @22 @112 +@669 := @340 @95 @92 @560 +@670 := @576 @1 +@673 := @575 (@670 @93) @581 +@674 := @600 @1 +@684 := (hbind : @573) -> + (hF : @673) -> (hA : @646) -> (hne : @590) -> @593 (fun (ro : @592) => @599 (@674 @604 @114 @22)) +@694 := {A : @25} -> + {f : @3} -> + {fn : @297} -> + {args : @350} -> + {env : @528} -> {F : @4} -> {o : @505} -> (hB : @666) -> (hfn : @638) -> (hwt : @669) -> @684 +@695 := @661 @2 +@697 := @662 @2 @22 +@699 := (n : @3) -> @697 @112 +@700 := @346 @92 +@701 := @700 @560 +@710 := {f : @3} -> + {fn : @297} -> + {args : @350} -> + {env : @528} -> {F : @4} -> {o : @505} -> (hB : @699) -> (hfn : @638) -> (hwt : @701) -> @684 +@711 := @695 @286 +@713 := (n : @3) -> @697 @286 +@714 := @635 @286 +@715 := @539 @714 +@716 := @715 @553 +@717 := @670 @286 +@718 := @575 @717 +@719 := @718 @581 +@720 := @643 @286 +@722 := @720 @95 @92 +@724 := @674 (@603 @286) +@732 := (hF : @719) -> (hA : @722) -> (hne : @590) -> @593 (fun (ro : @592) => @599 (@724 @114 @22)) +@741 := {fn : @297} -> + {args : @350} -> + {env : @528} -> + {F : @4} -> {o : @505} -> (hB : @713) -> (hfn : @716) -> (hwt : @701) -> (hbind : @573) -> @732 +@742 := @711 @316 +@744 := @715 (@552 @316) +@745 := @559 @316 +@746 := @700 @745 +@748 := @564 (@565 @316) +@760 := {args : @350} -> + {env : @528} -> + {F : @4} -> + {o : @505} -> + (hB : @713) -> (hfn : @744) -> (hwt : @746) -> (hbind : @563 (@748 @112 @292) @572) -> @732 +@761 := @742 @284 +@762 := @438 @281 +@764 := @346 @762 @745 +@767 := @282 (@15 @97) @281 +@771 := @563 (@748 @767 @292) @572 +@774 := @282 (@15 @93) @281 +@795 := {env : @528} -> + {F : @4} -> + {o : @505} -> + (hB : @713) -> + (hfn : @744) -> + (hwt : @764) -> + (hbind : @771) -> + (hF : @719) -> + (hA : @720 @774 @92) -> + (hne : @590) -> @593 (fun (ro : @592) => @599 (@724 (@282 (@15 #12) @281) @22)) +@796 := @761 @295 +@797 := @452 @281 +@799 := @346 @797 @745 +@807 := @563 (@748 @762 @292) (@571 (@293 (@290 @437) @292)) +@810 := @282 (@15 @95) @281 +@829 := {F : @4} -> + {o : @505} -> + (hB : @713) -> + (hfn : @744) -> + (hwt : @799) -> + (hbind : @807) -> + (hF : @719) -> + (hA : @720 @810 @92) -> + (hne : @590) -> @593 (fun (ro : @592) => @599 (@724 (@282 (@15 @114) @281) @22)) +@830 := @796 @296 +@831 := @469 @745 +@839 := @563 (@748 @797 @292) (@571 (@293 (@290 @451) @292)) +@841 := @718 (@580 @296) +@843 := @720 @767 @92 +@844 := @595 @296 +@863 := {o : @505} -> + (hB : @713) -> + (hfn : @744) -> + (hwt : @831) -> + (hbind : @839) -> + (hF : @841) -> + (hA : @843) -> + (hne : @590) -> @593 (fun (ro : @592) => @594 (@844 @95 @22) (@724 (@282 (@15 @104) @281) @22)) +@864 := @830 @492 +@865 := @477 @745 +@873 := @563 (@748 @468 @292) (@571 (@293 (@290 @434) @292)) +@874 := @720 @762 +@875 := @491 @112 +@876 := @874 @875 +@877 := @491 @97 +@895 := (hB : @713) -> + (hfn : @744) -> + (hwt : @865) -> + (hbind : @873) -> + (hF : @841) -> + (hA : @876) -> + (hne : @506 @877 @511) -> @593 (fun (ro : @592) => @594 (@844 (@491 @93) @22) (@724 @774 @22)) +@896 := @864 @320 +@897 := @485 @745 +@905 := @563 (@748 @476 @292) (@571 (@293 (@290 @448) @292)) +@906 := @720 @797 +@907 := @491 @92 +@925 := (hfn : @744) -> + (hwt : @897) -> + (hbind : @905) -> + (hF : @841) -> + (hA : @906 @907) -> + (hne : @506 @875 @511) -> @593 (fun (ro : @592) => @594 (@844 (@491 @95) @22) (@724 @810 @22)) +@926 := Eq.refl.{1} +@929 := @896 (@926 @538 @714) +@930 := @489 @745 +@938 := @563 (@748 @484 @292) (@571 (@293 (@290 @463) @292)) +@939 := @720 @468 +@940 := @491 @99 +@956 := (hwt : @930) -> + (hbind : @938) -> + (hF : @841) -> + (hA : @939 @940) -> + (hne : @506 @907 @511) -> @593 (fun (ro : @592) => @594 (@844 @877 @22) (@724 @767 @22)) +@957 := @929 @488 +@959 := @748 @284 @292 +@962 := @563 @959 (@571 @295) +@963 := @720 @476 +@964 := @491 @27 +@979 := (hbind : @962) -> + (hF : @841) -> + (hA : @963 @964) -> + (hne : @506 @940 @511) -> @593 (fun (ro : @592) => @594 (@844 @875 @22) (@724 @762 @22)) +@982 := @957 (@926 @562 @959) +@983 := @720 @484 +@984 := @491 @29 +@998 := (hF : @841) -> + (hA : @983 @984) -> + (hne : @506 @964 @511) -> @593 (fun (ro : @592) => @594 (@844 @907 @22) (@724 @797 @22)) +@1001 := @982 (@926 @574 @717) +@1015 := (hA : @720 @284 @492) -> + (hne : @506 @984 @511) -> @593 (fun (ro : @592) => @594 (@844 @940 @22) (@724 @468 @22)) +@1016 := @1001 @503 +@1027 := (hne : @506 @492 @511) -> @593 (fun (ro : @592) => @594 (@844 @964 @22) (@724 @476 @22)) +@1028 := @1016 @523 +@1034 := @594 (@844 @984 @22) (@724 @484 @22) +@1036 := @593 (fun (ro : @592) => @1034) +@1038 := @593 (fun (__e_ro : @592) => @1034) +@1042 := LexLeanPreservation.Rust.RepresentableL (@282 @252 @281) +@1043 := (__e_hrep : @1042) -> @1038 +@1044 := fun (__e_hrep : @1042) => @1028 +@1045 := (p : @7) -> @1043 +@1046 := fun (p : @7) => @1044 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustStd.lean deleted file mode 100644 index 94877cc7d..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (p : (Prod Nat Bool)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool) p)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.denote p) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool) p)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_bool) p) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.root p) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustStd.lex.tex new file mode 100644 index 000000000..163d04c54 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustStd.lex.tex @@ -0,0 +1,521 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd.root : @1045 := @1046 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd.flags +@3 := Nat +@4 := Bool +@5 := Prod.{0, 0} +@6 := @5 @3 +@7 := @6 @4 +@8 := #1 +@9 := LexLeanTarget.TargetSyntax.Value.nat +@10 := LexLeanTarget.TargetSyntax.Value.bool +@11 := LexLeanPreservation.encPair +@12 := @11 @3 +@13 := @12 @4 +@14 := @13 @9 +@15 := @14 @10 +@16 := @15 @8 +@17 := LexLeanTarget.TargetSyntax.Ty.nat +@18 := LexLeanTarget.TargetSyntax.Ty.bool +@19 := LexLeanTarget.TargetSyntax.Ty.pair +@20 := @19 @17 +@21 := @20 @18 +@22 := #0 +@23 := LexLeanTarget.TargetSyntax.Program +@24 := LexLeanPreservation.Rust.RCrate +@25 := LexLeanPreservation.Rust.Flags +@26 := LexLeanPreservation.Rust.WT +@27 := #3 +@28 := @26 @27 +@29 := #2 +@31 := @28 @29 @8 +@32 := @9 @22 +@38 := {p : @23} -> {c : @24} -> {A : @25} -> (n : @3) -> @31 @32 @17 +@40 := LexLeanPreservation.Rust.wt_nat @0 +@41 := @26 @0 +@43 := @41 @29 @8 +@48 := {c : @24} -> {A : @25} -> (n : @3) -> @43 @32 @17 +@49 := @40 @1 +@50 := @41 @1 +@51 := @50 @8 +@55 := {A : @25} -> (n : @3) -> @51 @32 @17 +@56 := @49 @2 +@57 := @50 @2 +@58 := @57 @32 +@59 := @58 @17 +@60 := (n : @3) -> @59 +@62 := fun (__x : @3) => @56 @22 +@63 := @10 @22 +@69 := {p : @23} -> {c : @24} -> {A : @25} -> (b : @4) -> @31 @63 @18 +@71 := LexLeanPreservation.Rust.wt_bool @0 +@76 := {c : @24} -> {A : @25} -> (b : @4) -> @43 @63 @18 +@77 := @71 @1 +@81 := {A : @25} -> (b : @4) -> @51 @63 @18 +@82 := @77 @2 +@83 := @57 @63 +@84 := @83 @18 +@85 := (b : @4) -> @84 +@87 := fun (__x : @4) => @82 @22 +@88 := Sort 1 +@89 := LexLeanTarget.TargetSyntax.Value +@90 := (a._@._internal._hyg.#0 : @8) -> @89 +@91 := LexLeanTarget.TargetSyntax.Ty +@92 := #5 +@93 := #9 +@94 := @26 @93 +@95 := #8 +@96 := @94 @95 +@97 := #7 +@98 := @96 @97 +@99 := #4 +@100 := @99 @22 +@103 := (x : @92) -> @98 @100 @29 +@104 := #10 +@110 := (x : @92) -> @26 @104 @93 @95 @100 @29 +@111 := @5 @97 +@112 := #6 +@113 := @111 @112 +@114 := #11 +@117 := @26 @114 @104 @93 +@122 := @11 @95 @97 @112 @92 @22 +@123 := @117 @122 +@125 := @19 @99 @27 +@138 := {p : @23} -> + {c : @24} -> + {A : @25} -> + {α : @88} -> + {β : @88} -> + {ea : @90} -> + {eb : @90} -> {s : @91} -> {t : @91} -> (ha : @103) -> (hb : @110) -> (x : @113) -> @123 @125 +@140 := LexLeanPreservation.Rust.wt_encPair @0 +@165 := {c : @24} -> + {A : @25} -> + {α : @88} -> + {β : @88} -> + {ea : @90} -> + {eb : @90} -> + {s : @91} -> + {t : @91} -> + (ha : (x : @92) -> @41 @95 @97 @100 @29) -> + (hb : (x : @92) -> @41 @93 @95 @100 @29) -> (x : @113) -> @41 @104 @93 @122 @125 +@166 := @140 @1 +@187 := {A : @25} -> + {α : @88} -> + {β : @88} -> + {ea : @90} -> + {eb : @90} -> + {s : @91} -> + {t : @91} -> + (ha : (x : @92) -> @50 @97 @100 @29) -> + (hb : (x : @92) -> @50 @95 @100 @29) -> (x : @113) -> @50 @93 @122 @125 +@188 := @166 @2 +@190 := @57 @100 @29 +@191 := (x : @92) -> @190 +@202 := {α : @88} -> + {β : @88} -> + {ea : @90} -> + {eb : @90} -> {s : @91} -> {t : @91} -> (ha : @191) -> (hb : @191) -> (x : @113) -> @57 @122 @125 +@203 := @188 @3 +@204 := (a._@._internal._hyg.#0 : @3) -> @89 +@205 := (x : @3) -> @190 +@220 := {β : @88} -> + {ea : @204} -> + {eb : @90} -> + {s : @91} -> + {t : @91} -> (ha : @205) -> (hb : @191) -> (x : @6 @112) -> @57 (@12 @97 @112 @92 @22) @125 +@221 := @203 @4 +@222 := (a._@._internal._hyg.#0 : @4) -> @89 +@223 := (x : @4) -> @190 +@235 := {ea : @204} -> + {eb : @222} -> + {s : @91} -> {t : @91} -> (ha : @205) -> (hb : @223) -> (x : @7) -> @57 (@13 @112 @92 @22) @125 +@236 := @221 @9 +@238 := (x : @3) -> @58 @29 +@248 := {eb : @222} -> + {s : @91} -> {t : @91} -> (ha : @238) -> (hb : @223) -> (x : @7) -> @57 (@14 @92 @22) @125 +@249 := @236 @10 +@251 := (x : @4) -> @83 @29 +@252 := @15 @22 +@253 := @57 @252 +@259 := {s : @91} -> {t : @91} -> (ha : @238) -> (hb : @251) -> (x : @7) -> @253 @125 +@260 := @249 @17 +@261 := (x : @3) -> @59 +@267 := {t : @91} -> (ha : @261) -> (hb : @251) -> (x : @7) -> @253 (@20 @27) +@268 := @260 @18 +@273 := (ha : @261) -> (hb : (x : @4) -> @84) -> (x : @7) -> @253 @21 +@276 := @268 @62 @87 @8 +@278 := @57 @16 @21 +@279 := List.nil.{0} +@280 := List.cons.{0} +@281 := @279 @89 +@282 := @280 @89 +@284 := @282 @16 @281 +@285 := @6 @89 +@286 := 0 +@290 := Prod.mk.{0, 0} @3 @89 @286 +@291 := @290 @16 +@292 := @279 @285 +@293 := @280 @285 +@295 := @293 @291 @292 +@296 := Bool.false +@297 := LexLeanTarget.TargetSyntax.Function +@298 := LexLeanTarget.TargetSyntax.Program.functions +@299 := @298 @0 +@300 := @279 @3 +@301 := @279 @91 +@302 := LexLeanTarget.TargetSyntax.Ty.unit +@303 := LexLeanTarget.TargetSyntax.Value.unit +@306 := LexLeanTarget.TargetSyntax.Expr.value @302 @303 +@311 := LexLeanTarget.TargetSyntax.Function.mk @300 @301 @302 @306 +@316 := List.getD.{0} @297 @299 @286 @311 +@320 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd.root @22 @286 +@321 := LexLeanPreservation.Rust.WTL +@329 := {p : @23} -> {c : @24} -> {A : @25} -> @321 @29 @8 @22 @281 @301 +@331 := LexLeanPreservation.Rust.wtl_nil @0 +@332 := @321 @0 +@338 := {c : @24} -> {A : @25} -> @332 @8 @22 @281 @301 +@339 := @331 @1 +@340 := @332 @1 +@344 := {A : @25} -> @340 @22 @281 @301 +@345 := @339 @2 +@346 := @340 @2 +@347 := @346 @281 +@348 := @347 @301 +@349 := List.{0} +@350 := @349 @89 +@351 := @349 @91 +@356 := @26 @112 @92 @99 @27 @29 +@361 := @321 @97 @112 @92 @29 @8 +@364 := @321 @95 @97 @112 +@366 := @282 @92 @27 +@367 := @364 @366 +@368 := @280 @91 +@370 := @368 @99 @29 +@380 := {p : @23} -> + {c : @24} -> + {A : @25} -> + {v : @89} -> {t : @91} -> {vs : @350} -> {ts : @351} -> (h : @356) -> (hs : @361) -> @367 @370 +@382 := LexLeanPreservation.Rust.wtl_cons @0 +@402 := {c : @24} -> + {A : @25} -> + {v : @89} -> + {t : @91} -> + {vs : @350} -> + {ts : @351} -> (h : @41 @92 @99 @27 @29) -> (hs : @332 @112 @92 @29 @8) -> @332 @97 @112 @366 @370 +@403 := @382 @1 +@419 := {A : @25} -> + {v : @89} -> + {t : @91} -> + {vs : @350} -> + {ts : @351} -> (h : @50 @99 @27 @29) -> (hs : @340 @92 @29 @8) -> @340 @112 @366 @370 +@420 := @403 @2 +@422 := @57 @27 @29 +@424 := @346 @29 @8 +@432 := {v : @89} -> + {t : @91} -> {vs : @350} -> {ts : @351} -> (h : @422) -> (hs : @424) -> @346 @366 @370 +@433 := @420 @16 +@434 := @15 @99 +@436 := @57 @434 @29 +@437 := @15 @112 +@438 := @282 @437 +@446 := {t : @91} -> {vs : @350} -> {ts : @351} -> (h : @436) -> (hs : @424) -> @346 (@438 @27) @370 +@447 := @433 @21 +@448 := @15 @27 +@450 := @57 @448 @21 +@451 := @15 @92 +@452 := @282 @451 +@454 := @346 (@452 @27) +@455 := @368 @21 +@456 := @455 @29 +@461 := {vs : @350} -> {ts : @351} -> (h : @450) -> (hs : @424) -> @454 @456 +@462 := @447 @281 +@463 := @15 @29 +@465 := @57 @463 @21 +@466 := @347 @8 +@468 := @282 @434 @281 +@469 := @346 @468 +@473 := {ts : @351} -> (h : @465) -> (hs : @466) -> @469 @456 +@474 := @462 @301 +@476 := @282 @448 @281 +@477 := @346 @476 +@478 := @455 @301 +@481 := (h : @278) -> (hs : @348) -> @477 @478 +@482 := @474 @276 +@484 := @282 @463 @281 +@485 := @346 @484 +@487 := (hs : @348) -> @485 @478 +@488 := @482 @345 +@489 := @346 @284 +@490 := @489 @478 +@491 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.denote +@492 := @491 @8 +@493 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.__fits_0 +@494 := @493 @8 +@496 := Coverage.Main.pairs @8 +@501 := @11 @4 @3 @10 @9 @496 +@503 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.root @8 +@504 := Ne.{1} +@505 := LexLeanPreservation.Obs +@506 := @504 @505 +@507 := LexLeanPreservation.Rel +@510 := @506 (@507 @8 @22) +@511 := LexLeanPreservation.Obs.stuck +@514 := (f : @4) -> (v : @89) -> @510 @511 +@516 := LexLeanPreservation.Rust.rel_ne_stuck @494 +@522 := (v : @89) -> @506 (@507 (@493 @29) @22) @511 +@523 := @516 @501 +@527 := @506 (@507 @494 @501) @511 +@528 := @349 @285 +@529 := LexLeanPreservation.Rust.FunSem +@535 := (n : @3) -> @529 @93 @95 @97 @22 @112 +@536 := Eq.{1} +@537 := Option.{0} +@538 := @537 @297 +@539 := @536 @538 +@546 := LexLeanRuntime.index (@349 @297) @297 (LexLeanRuntime.instIndexableList @297) +@550 := @539 (@546 (@298 @93) @112) +@551 := Option.some.{0} +@552 := @551 @297 +@553 := @552 @92 +@554 := @550 @553 +@558 := @321 @104 @93 @95 @92 +@559 := LexLeanTarget.TargetSyntax.Function.types +@560 := @559 @112 +@561 := @558 @560 +@562 := @537 @528 +@563 := @536 @562 +@564 := LexLeanTarget.TargetSemantics.bindAll +@565 := LexLeanTarget.TargetSyntax.Function.parameters +@570 := @563 (@564 (@565 @97) @112 @292) +@571 := @551 @528 +@572 := @571 @92 +@573 := @570 @572 +@574 := @537 @4 +@575 := @536 @574 +@576 := LexLeanPreservation.Rust.fnFallible +@579 := @575 (@576 @114 @93) +@580 := @551 @4 +@581 := @580 @92 +@582 := @579 @581 +@583 := LexLeanPreservation.RunConv +@584 := #13 +@588 := @583 @584 @104 @95 @92 +@590 := @506 @112 @511 +@591 := Exists.{1} +@592 := LexLeanPreservation.Rust.ROut +@593 := @591 @592 +@594 := And +@595 := LexLeanPreservation.Rust.RealizesFn +@599 := @594 (@595 @93 @95 @22) +@600 := LexLeanPreservation.Rust.RCI +@602 := @600 #15 +@603 := LexLeanPreservation.Rust.fnIdent +@604 := @603 @584 +@611 := (hne : @590) -> @593 (fun (ro : @592) => @599 (@602 @604 @114 @22)) +@626 := {p : @23} -> + {c : @24} -> + {A : @25} -> + {f : @3} -> + {fn : @297} -> + {args : @350} -> + {env : @528} -> + {F : @4} -> + {o : @505} -> + (hB : @535) -> + (hfn : @554) -> (hwt : @561) -> (hbind : @573) -> (hF : @582) -> (hA : @588) -> @611 +@628 := LexLeanPreservation.Rust.compose @0 +@629 := @529 @0 +@634 := (n : @3) -> @629 @95 @97 @22 @112 +@635 := @546 @299 +@638 := @539 (@635 @112) @553 +@642 := @332 @93 @95 @92 @560 +@643 := @583 @0 +@646 := @643 @104 @95 @92 +@660 := {c : @24} -> + {A : @25} -> + {f : @3} -> + {fn : @297} -> + {args : @350} -> + {env : @528} -> + {F : @4} -> + {o : @505} -> + (hB : @634) -> + (hfn : @638) -> (hwt : @642) -> (hbind : @573) -> (hF : @582) -> (hA : @646) -> @611 +@661 := @628 @1 +@662 := @629 @1 +@666 := (n : @3) -> @662 @97 @22 @112 +@669 := @340 @95 @92 @560 +@670 := @576 @1 +@673 := @575 (@670 @93) @581 +@674 := @600 @1 +@684 := (hbind : @573) -> + (hF : @673) -> (hA : @646) -> (hne : @590) -> @593 (fun (ro : @592) => @599 (@674 @604 @114 @22)) +@694 := {A : @25} -> + {f : @3} -> + {fn : @297} -> + {args : @350} -> + {env : @528} -> {F : @4} -> {o : @505} -> (hB : @666) -> (hfn : @638) -> (hwt : @669) -> @684 +@695 := @661 @2 +@697 := @662 @2 @22 +@699 := (n : @3) -> @697 @112 +@700 := @346 @92 +@701 := @700 @560 +@710 := {f : @3} -> + {fn : @297} -> + {args : @350} -> + {env : @528} -> {F : @4} -> {o : @505} -> (hB : @699) -> (hfn : @638) -> (hwt : @701) -> @684 +@711 := @695 @286 +@713 := (n : @3) -> @697 @286 +@714 := @635 @286 +@715 := @539 @714 +@716 := @715 @553 +@717 := @670 @286 +@718 := @575 @717 +@719 := @718 @581 +@720 := @643 @286 +@722 := @720 @95 @92 +@724 := @674 (@603 @286) +@732 := (hF : @719) -> (hA : @722) -> (hne : @590) -> @593 (fun (ro : @592) => @599 (@724 @114 @22)) +@741 := {fn : @297} -> + {args : @350} -> + {env : @528} -> + {F : @4} -> {o : @505} -> (hB : @713) -> (hfn : @716) -> (hwt : @701) -> (hbind : @573) -> @732 +@742 := @711 @316 +@744 := @715 (@552 @316) +@745 := @559 @316 +@746 := @700 @745 +@748 := @564 (@565 @316) +@760 := {args : @350} -> + {env : @528} -> + {F : @4} -> + {o : @505} -> + (hB : @713) -> (hfn : @744) -> (hwt : @746) -> (hbind : @563 (@748 @112 @292) @572) -> @732 +@761 := @742 @284 +@762 := @438 @281 +@764 := @346 @762 @745 +@767 := @282 (@15 @97) @281 +@771 := @563 (@748 @767 @292) @572 +@774 := @282 (@15 @93) @281 +@795 := {env : @528} -> + {F : @4} -> + {o : @505} -> + (hB : @713) -> + (hfn : @744) -> + (hwt : @764) -> + (hbind : @771) -> + (hF : @719) -> + (hA : @720 @774 @92) -> + (hne : @590) -> @593 (fun (ro : @592) => @599 (@724 (@282 (@15 #12) @281) @22)) +@796 := @761 @295 +@797 := @452 @281 +@799 := @346 @797 @745 +@807 := @563 (@748 @762 @292) (@571 (@293 (@290 @437) @292)) +@810 := @282 (@15 @95) @281 +@829 := {F : @4} -> + {o : @505} -> + (hB : @713) -> + (hfn : @744) -> + (hwt : @799) -> + (hbind : @807) -> + (hF : @719) -> + (hA : @720 @810 @92) -> + (hne : @590) -> @593 (fun (ro : @592) => @599 (@724 (@282 (@15 @114) @281) @22)) +@830 := @796 @296 +@831 := @469 @745 +@839 := @563 (@748 @797 @292) (@571 (@293 (@290 @451) @292)) +@841 := @718 (@580 @296) +@843 := @720 @767 @92 +@844 := @595 @296 +@863 := {o : @505} -> + (hB : @713) -> + (hfn : @744) -> + (hwt : @831) -> + (hbind : @839) -> + (hF : @841) -> + (hA : @843) -> + (hne : @590) -> @593 (fun (ro : @592) => @594 (@844 @95 @22) (@724 (@282 (@15 @104) @281) @22)) +@864 := @830 @492 +@865 := @477 @745 +@873 := @563 (@748 @468 @292) (@571 (@293 (@290 @434) @292)) +@874 := @720 @762 +@875 := @491 @112 +@876 := @874 @875 +@877 := @491 @97 +@895 := (hB : @713) -> + (hfn : @744) -> + (hwt : @865) -> + (hbind : @873) -> + (hF : @841) -> + (hA : @876) -> + (hne : @506 @877 @511) -> @593 (fun (ro : @592) => @594 (@844 (@491 @93) @22) (@724 @774 @22)) +@896 := @864 @320 +@897 := @485 @745 +@905 := @563 (@748 @476 @292) (@571 (@293 (@290 @448) @292)) +@906 := @720 @797 +@907 := @491 @92 +@925 := (hfn : @744) -> + (hwt : @897) -> + (hbind : @905) -> + (hF : @841) -> + (hA : @906 @907) -> + (hne : @506 @875 @511) -> @593 (fun (ro : @592) => @594 (@844 (@491 @95) @22) (@724 @810 @22)) +@926 := Eq.refl.{1} +@929 := @896 (@926 @538 @714) +@930 := @489 @745 +@938 := @563 (@748 @484 @292) (@571 (@293 (@290 @463) @292)) +@939 := @720 @468 +@940 := @491 @99 +@956 := (hwt : @930) -> + (hbind : @938) -> + (hF : @841) -> + (hA : @939 @940) -> + (hne : @506 @907 @511) -> @593 (fun (ro : @592) => @594 (@844 @877 @22) (@724 @767 @22)) +@957 := @929 @488 +@959 := @748 @284 @292 +@962 := @563 @959 (@571 @295) +@963 := @720 @476 +@964 := @491 @27 +@979 := (hbind : @962) -> + (hF : @841) -> + (hA : @963 @964) -> + (hne : @506 @940 @511) -> @593 (fun (ro : @592) => @594 (@844 @875 @22) (@724 @762 @22)) +@982 := @957 (@926 @562 @959) +@983 := @720 @484 +@984 := @491 @29 +@998 := (hF : @841) -> + (hA : @983 @984) -> + (hne : @506 @964 @511) -> @593 (fun (ro : @592) => @594 (@844 @907 @22) (@724 @797 @22)) +@1001 := @982 (@926 @574 @717) +@1015 := (hA : @720 @284 @492) -> + (hne : @506 @984 @511) -> @593 (fun (ro : @592) => @594 (@844 @940 @22) (@724 @468 @22)) +@1016 := @1001 @503 +@1027 := (hne : @506 @492 @511) -> @593 (fun (ro : @592) => @594 (@844 @964 @22) (@724 @476 @22)) +@1028 := @1016 @523 +@1034 := @594 (@844 @984 @22) (@724 @484 @22) +@1036 := @593 (fun (ro : @592) => @1034) +@1038 := @593 (fun (__e_ro : @592) => @1034) +@1042 := LexLeanPreservation.Rust.RepresentableL (@282 @252 @281) +@1043 := (__e_hrep : @1042) -> @1038 +@1044 := fun (__e_hrep : @1042) => @1028 +@1045 := (p : @7) -> @1043 +@1046 := fun (p : @7) => @1044 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustCore.lean deleted file mode 100644 index 1c0bb3d62..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (base : Nat) (offset : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat base), (_root_.LexLeanTarget.TargetSyntax.Value.nat offset)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.denote base offset) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat base), (_root_.LexLeanTarget.TargetSyntax.Value.nat offset)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat base) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat offset) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.root base offset) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustCore.lex.tex new file mode 100644 index 000000000..7b76f6148 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustCore.lex.tex @@ -0,0 +1,462 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore.root : @914 := @915 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@65 := Prod.{0, 0} @3 @54 +@66 := 1 +@69 := Prod.mk.{0, 0} @3 @54 +@70 := @69 @66 +@71 := @70 @50 +@72 := 0 +@73 := @69 @72 +@74 := @73 @6 +@75 := @55 @65 +@76 := @56 @65 +@78 := @76 @74 @75 +@80 := @76 @71 @78 +@81 := Bool.true +@82 := LexLeanTarget.TargetSyntax.Function +@83 := LexLeanTarget.TargetSyntax.Program.functions +@84 := @83 @0 +@85 := LexLeanTarget.TargetSyntax.Ty +@86 := @55 @3 +@87 := @55 @85 +@88 := LexLeanTarget.TargetSyntax.Ty.unit +@89 := LexLeanTarget.TargetSyntax.Value.unit +@92 := LexLeanTarget.TargetSyntax.Expr.value @88 @89 +@97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 +@102 := List.getD.{0} @82 @84 @72 @97 +@106 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore.root @17 @72 +@107 := LexLeanPreservation.Rust.WTL +@115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 +@117 := LexLeanPreservation.Rust.wtl_nil @0 +@118 := @107 @0 +@124 := {c : @9} -> {A : @10} -> @118 @15 @17 @57 @87 +@125 := @117 @1 +@126 := @118 @1 +@130 := {A : @10} -> @126 @17 @57 @87 +@131 := @125 @2 +@132 := @126 @2 +@133 := @132 @57 +@134 := @133 @87 +@135 := List.{0} +@136 := @135 @54 +@137 := @135 @85 +@138 := #6 +@139 := @11 @138 +@140 := #5 +@141 := @139 @140 +@142 := #4 +@145 := @141 @142 @12 @4 +@146 := #7 +@151 := @107 @146 @138 @140 @4 @15 +@152 := #8 +@155 := @107 @152 @146 @138 +@157 := @58 @140 @12 +@158 := @155 @157 +@159 := @56 @85 +@161 := @159 @142 @4 +@171 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @145) -> (hs : @151) -> @158 @161 +@173 := LexLeanPreservation.Rust.wtl_cons @0 +@193 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> + (h : @27 @140 @142 @12 @4) -> (hs : @118 @138 @140 @4 @15) -> @118 @146 @138 @157 @161 +@194 := @173 @1 +@210 := {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> (h : @36 @142 @12 @4) -> (hs : @126 @140 @4 @15) -> @126 @138 @157 @161 +@211 := @194 @2 +@213 := @43 @12 @4 +@215 := @132 @4 @15 +@223 := {v : @54} -> + {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @213) -> (hs : @215) -> @132 @157 @161 +@224 := @211 @50 +@225 := @5 @142 +@226 := @43 @225 +@227 := @226 @4 +@228 := @5 @138 +@229 := @58 @228 +@231 := @132 (@229 @12) +@237 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @227) -> (hs : @215) -> @231 @161 +@238 := @224 @7 +@239 := @5 @12 +@241 := @43 @239 @7 +@242 := @5 @140 +@243 := @58 @242 +@245 := @132 (@243 @12) +@246 := @159 @7 +@247 := @246 @4 +@252 := {vs : @136} -> {ts : @137} -> (h : @241) -> (hs : @215) -> @245 @247 +@253 := @238 @57 +@254 := @133 @15 +@255 := @58 @225 +@256 := @255 @57 +@261 := {ts : @137} -> (h : @49) -> (hs : @254) -> @132 @256 @247 +@262 := @253 @87 +@263 := @58 @239 +@264 := @263 @57 +@265 := @132 @264 +@266 := @246 @87 +@269 := (h : @53) -> (hs : @134) -> @265 @266 +@270 := @262 @51 +@271 := @61 @57 +@273 := @132 @271 @266 +@274 := (hs : @134) -> @273 +@275 := @270 @131 +@277 := @132 @60 @266 +@278 := @211 @6 +@280 := @43 @242 @4 +@281 := @5 @146 +@282 := @58 @281 +@290 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @280) -> (hs : @215) -> @132 (@282 @12) @161 +@291 := @278 @7 +@297 := {vs : @136} -> {ts : @137} -> (h : @226 @7) -> (hs : @215) -> @231 @247 +@298 := @291 @60 +@299 := @265 @15 +@300 := @243 @256 +@301 := @132 @300 +@305 := {ts : @137} -> (h : @241) -> (hs : @299) -> @301 @247 +@306 := @298 @266 +@307 := @255 @264 +@308 := @132 @307 +@309 := @246 @266 +@312 := (h : @49) -> (hs : @273) -> @308 @309 +@313 := @306 @47 +@314 := @263 @271 +@315 := @132 @314 +@317 := (hs : @277) -> @315 @309 +@318 := @313 @275 +@319 := @132 @62 +@320 := @319 @309 +@321 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.__fits_0 +@326 := @324 @4 @15 +@330 := @5 (Coverage.Main.higher @4 @15) +@333 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.root @4 @15 +@334 := Bool +@335 := Ne.{1} +@336 := LexLeanPreservation.Obs +@337 := @335 @336 +@338 := LexLeanPreservation.Rel +@341 := @337 (@338 @15 @17) +@342 := LexLeanPreservation.Obs.stuck +@345 := (f : @334) -> (v : @54) -> @341 @342 +@347 := LexLeanPreservation.Rust.rel_ne_stuck @326 +@354 := (v : @54) -> @337 (@338 (@324 @12 @4) @17) @342 +@355 := @347 @330 +@359 := @337 (@338 @326 @330) @342 +@360 := @135 @65 +@361 := LexLeanPreservation.Rust.FunSem +@362 := #9 +@368 := (n : @3) -> @361 @362 @152 @146 @17 @138 +@369 := Eq.{1} +@370 := Option.{0} +@371 := @370 @82 +@372 := @369 @371 +@379 := LexLeanRuntime.index (@135 @82) @82 (LexLeanRuntime.instIndexableList @82) +@383 := @372 (@379 (@83 @362) @138) +@384 := Option.some.{0} +@385 := @384 @82 +@386 := @385 @140 +@387 := @383 @386 +@388 := #10 +@392 := @107 @388 @362 @152 @140 +@393 := LexLeanTarget.TargetSyntax.Function.types +@394 := @393 @138 +@395 := @392 @394 +@396 := @370 @360 +@397 := @369 @396 +@398 := LexLeanTarget.TargetSemantics.bindAll +@399 := LexLeanTarget.TargetSyntax.Function.parameters +@404 := @397 (@398 (@399 @146) @138 @75) +@405 := @384 @360 +@406 := @405 @140 +@407 := @404 @406 +@408 := @370 @334 +@409 := @369 @408 +@410 := LexLeanPreservation.Rust.fnFallible +@411 := #11 +@414 := @409 (@410 @411 @362) +@415 := @384 @334 +@416 := @415 @140 +@417 := @414 @416 +@418 := LexLeanPreservation.RunConv +@419 := #13 +@423 := @418 @419 @388 @152 @140 +@425 := @337 @138 @342 +@426 := Exists.{1} +@427 := LexLeanPreservation.Rust.ROut +@428 := @426 @427 +@429 := And +@430 := LexLeanPreservation.Rust.RealizesFn +@434 := @429 (@430 @362 @152 @17) +@435 := LexLeanPreservation.Rust.RCI +@437 := @435 #15 +@438 := LexLeanPreservation.Rust.fnIdent +@439 := @438 @419 +@446 := (hne : @425) -> @428 (fun (ro : @427) => @434 (@437 @439 @411 @17)) +@461 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @368) -> + (hfn : @387) -> (hwt : @395) -> (hbind : @407) -> (hF : @417) -> (hA : @423) -> @446 +@463 := LexLeanPreservation.Rust.compose @0 +@464 := @361 @0 +@469 := (n : @3) -> @464 @152 @146 @17 @138 +@470 := @379 @84 +@473 := @372 (@470 @138) @386 +@477 := @118 @362 @152 @140 @394 +@478 := @418 @0 +@481 := @478 @388 @152 @140 +@495 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @469) -> + (hfn : @473) -> (hwt : @477) -> (hbind : @407) -> (hF : @417) -> (hA : @481) -> @446 +@496 := @463 @1 +@497 := @464 @1 +@501 := (n : @3) -> @497 @146 @17 @138 +@504 := @126 @152 @140 @394 +@505 := @410 @1 +@508 := @409 (@505 @362) @416 +@509 := @435 @1 +@519 := (hbind : @407) -> + (hF : @508) -> (hA : @481) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@509 @439 @411 @17)) +@529 := {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> {F : @334} -> {o : @336} -> (hB : @501) -> (hfn : @473) -> (hwt : @504) -> @519 +@530 := @496 @2 +@532 := @497 @2 @17 +@534 := (n : @3) -> @532 @138 +@535 := @132 @140 +@536 := @535 @394 +@545 := {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> {F : @334} -> {o : @336} -> (hB : @534) -> (hfn : @473) -> (hwt : @536) -> @519 +@546 := @530 @72 +@548 := (n : @3) -> @532 @72 +@549 := @470 @72 +@550 := @372 @549 +@551 := @550 @386 +@552 := @505 @72 +@553 := @409 @552 +@554 := @553 @416 +@555 := @478 @72 +@557 := @555 @152 @140 +@559 := @509 (@438 @72) +@567 := (hF : @554) -> (hA : @557) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 @411 @17)) +@576 := {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> {o : @336} -> (hB : @548) -> (hfn : @551) -> (hwt : @536) -> (hbind : @407) -> @567 +@577 := @546 @102 +@579 := @550 (@385 @102) +@580 := @393 @102 +@581 := @535 @580 +@583 := @398 (@399 @102) +@595 := {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @548) -> (hfn : @579) -> (hwt : @581) -> (hbind : @397 (@583 @138 @75) @406) -> @567 +@596 := @577 @62 +@598 := @282 (@229 @57) +@600 := @132 @598 @580 +@602 := @58 (@5 @152) +@604 := @602 (@282 @57) +@608 := @397 (@583 @604 @75) @406 +@610 := @58 (@5 @388) +@612 := @58 (@5 @362) +@614 := @610 (@612 @57) +@616 := @555 @614 @140 +@618 := @58 (@5 @419) +@621 := @58 (@5 #12) +@638 := {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @600) -> + (hbind : @608) -> + (hF : @554) -> + (hA : @616) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 (@618 (@621 @57)) @17)) +@639 := @596 @80 +@641 := @229 (@243 @57) +@643 := @132 @641 @580 +@654 := @397 (@583 @598 @75) (@405 (@76 (@70 @228) (@76 (@73 @281) @75))) +@656 := @612 (@602 @57) +@658 := @555 @656 @140 +@660 := @58 (@5 @411) +@676 := {F : @334} -> + {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @643) -> + (hbind : @654) -> + (hF : @554) -> + (hA : @658) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 (@621 (@660 @57)) @17)) +@677 := @639 @81 +@678 := @301 @580 +@689 := @397 (@583 @641 @75) (@405 (@76 (@70 @242) (@76 (@73 @228) @75))) +@691 := @553 (@415 @81) +@693 := @555 @604 @140 +@694 := @430 @81 +@712 := {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @678) -> + (hbind : @689) -> + (hF : @691) -> + (hA : @693) -> + (hne : @425) -> @428 (fun (ro : @427) => @429 (@694 @152 @17) (@559 (@660 (@610 @57)) @17)) +@713 := @677 @323 +@714 := @308 @580 +@725 := @397 (@583 @300 @75) (@405 (@76 (@70 @225) (@76 (@73 @242) @75))) +@726 := @555 @598 +@728 := @321 @146 @138 +@729 := @726 @728 +@731 := @321 @152 @146 +@750 := (hB : @548) -> + (hfn : @579) -> + (hwt : @714) -> + (hbind : @725) -> + (hF : @691) -> + (hA : @729) -> + (hne : @337 @731 @342) -> + @428 (fun (ro : @427) => @429 (@694 (@321 @388 @362) @17) (@559 @614 @17)) +@751 := @713 @106 +@752 := @315 @580 +@763 := @397 (@583 @307 @75) (@405 (@76 (@70 @239) (@76 (@73 @225) @75))) +@764 := @555 @641 +@766 := @321 @138 @140 +@785 := (hfn : @579) -> + (hwt : @752) -> + (hbind : @763) -> + (hF : @691) -> + (hA : @764 @766) -> + (hne : @337 @728 @342) -> + @428 (fun (ro : @427) => @429 (@694 (@321 @362 @152) @17) (@559 @656 @17)) +@786 := Eq.refl.{1} +@789 := @751 (@786 @371 @549) +@790 := @319 @580 +@801 := @397 (@583 @314 @75) (@405 (@76 (@70 @6) (@76 (@73 @239) @75))) +@802 := @555 @300 +@804 := @321 @140 @142 +@820 := (hwt : @790) -> + (hbind : @801) -> + (hF : @691) -> + (hA : @802 @804) -> + (hne : @337 @766 @342) -> @428 (fun (ro : @427) => @429 (@694 @731 @17) (@559 @604 @17)) +@821 := @789 @318 +@823 := @583 @62 @75 +@826 := @397 @823 (@405 @80) +@827 := @555 @307 +@829 := @321 @142 @12 +@844 := (hbind : @826) -> + (hF : @691) -> + (hA : @827 @829) -> + (hne : @337 @804 @342) -> @428 (fun (ro : @427) => @429 (@694 @728 @17) (@559 @598 @17)) +@847 := @821 (@786 @396 @823) +@848 := @555 @314 +@850 := @321 @12 @4 +@864 := (hF : @691) -> + (hA : @848 @850) -> + (hne : @337 @829 @342) -> @428 (fun (ro : @427) => @429 (@694 @766 @17) (@559 @641 @17)) +@867 := @847 (@786 @408 @552) +@881 := (hA : @555 @62 @323) -> + (hne : @337 @850 @342) -> @428 (fun (ro : @427) => @429 (@694 @804 @17) (@559 @300 @17)) +@882 := @867 @333 +@893 := (hne : @337 @323 @342) -> @428 (fun (ro : @427) => @429 (@694 @829 @17) (@559 @307 @17)) +@894 := @882 @355 +@900 := @429 (@694 @850 @17) (@559 @314 @17) +@902 := @428 (fun (ro : @427) => @900) +@904 := @428 (fun (__e_ro : @427) => @900) +@909 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@910 := (__e_hrep : @909) -> @904 +@911 := fun (__e_hrep : @909) => @894 +@912 := (offset : @3) -> @910 +@913 := fun (offset : @3) => @911 +@914 := (base : @3) -> @912 +@915 := fun (base : @3) => @913 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustStd.lean deleted file mode 100644 index 74207e1d3..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (base : Nat) (offset : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat base), (_root_.LexLeanTarget.TargetSyntax.Value.nat offset)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.denote base offset) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat base), (_root_.LexLeanTarget.TargetSyntax.Value.nat offset)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat base) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat offset) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.root base offset) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustStd.lex.tex new file mode 100644 index 000000000..19c978828 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustStd.lex.tex @@ -0,0 +1,462 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd.root : @914 := @915 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@65 := Prod.{0, 0} @3 @54 +@66 := 1 +@69 := Prod.mk.{0, 0} @3 @54 +@70 := @69 @66 +@71 := @70 @50 +@72 := 0 +@73 := @69 @72 +@74 := @73 @6 +@75 := @55 @65 +@76 := @56 @65 +@78 := @76 @74 @75 +@80 := @76 @71 @78 +@81 := Bool.true +@82 := LexLeanTarget.TargetSyntax.Function +@83 := LexLeanTarget.TargetSyntax.Program.functions +@84 := @83 @0 +@85 := LexLeanTarget.TargetSyntax.Ty +@86 := @55 @3 +@87 := @55 @85 +@88 := LexLeanTarget.TargetSyntax.Ty.unit +@89 := LexLeanTarget.TargetSyntax.Value.unit +@92 := LexLeanTarget.TargetSyntax.Expr.value @88 @89 +@97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 +@102 := List.getD.{0} @82 @84 @72 @97 +@106 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd.root @17 @72 +@107 := LexLeanPreservation.Rust.WTL +@115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 +@117 := LexLeanPreservation.Rust.wtl_nil @0 +@118 := @107 @0 +@124 := {c : @9} -> {A : @10} -> @118 @15 @17 @57 @87 +@125 := @117 @1 +@126 := @118 @1 +@130 := {A : @10} -> @126 @17 @57 @87 +@131 := @125 @2 +@132 := @126 @2 +@133 := @132 @57 +@134 := @133 @87 +@135 := List.{0} +@136 := @135 @54 +@137 := @135 @85 +@138 := #6 +@139 := @11 @138 +@140 := #5 +@141 := @139 @140 +@142 := #4 +@145 := @141 @142 @12 @4 +@146 := #7 +@151 := @107 @146 @138 @140 @4 @15 +@152 := #8 +@155 := @107 @152 @146 @138 +@157 := @58 @140 @12 +@158 := @155 @157 +@159 := @56 @85 +@161 := @159 @142 @4 +@171 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @145) -> (hs : @151) -> @158 @161 +@173 := LexLeanPreservation.Rust.wtl_cons @0 +@193 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> + (h : @27 @140 @142 @12 @4) -> (hs : @118 @138 @140 @4 @15) -> @118 @146 @138 @157 @161 +@194 := @173 @1 +@210 := {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> (h : @36 @142 @12 @4) -> (hs : @126 @140 @4 @15) -> @126 @138 @157 @161 +@211 := @194 @2 +@213 := @43 @12 @4 +@215 := @132 @4 @15 +@223 := {v : @54} -> + {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @213) -> (hs : @215) -> @132 @157 @161 +@224 := @211 @50 +@225 := @5 @142 +@226 := @43 @225 +@227 := @226 @4 +@228 := @5 @138 +@229 := @58 @228 +@231 := @132 (@229 @12) +@237 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @227) -> (hs : @215) -> @231 @161 +@238 := @224 @7 +@239 := @5 @12 +@241 := @43 @239 @7 +@242 := @5 @140 +@243 := @58 @242 +@245 := @132 (@243 @12) +@246 := @159 @7 +@247 := @246 @4 +@252 := {vs : @136} -> {ts : @137} -> (h : @241) -> (hs : @215) -> @245 @247 +@253 := @238 @57 +@254 := @133 @15 +@255 := @58 @225 +@256 := @255 @57 +@261 := {ts : @137} -> (h : @49) -> (hs : @254) -> @132 @256 @247 +@262 := @253 @87 +@263 := @58 @239 +@264 := @263 @57 +@265 := @132 @264 +@266 := @246 @87 +@269 := (h : @53) -> (hs : @134) -> @265 @266 +@270 := @262 @51 +@271 := @61 @57 +@273 := @132 @271 @266 +@274 := (hs : @134) -> @273 +@275 := @270 @131 +@277 := @132 @60 @266 +@278 := @211 @6 +@280 := @43 @242 @4 +@281 := @5 @146 +@282 := @58 @281 +@290 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @280) -> (hs : @215) -> @132 (@282 @12) @161 +@291 := @278 @7 +@297 := {vs : @136} -> {ts : @137} -> (h : @226 @7) -> (hs : @215) -> @231 @247 +@298 := @291 @60 +@299 := @265 @15 +@300 := @243 @256 +@301 := @132 @300 +@305 := {ts : @137} -> (h : @241) -> (hs : @299) -> @301 @247 +@306 := @298 @266 +@307 := @255 @264 +@308 := @132 @307 +@309 := @246 @266 +@312 := (h : @49) -> (hs : @273) -> @308 @309 +@313 := @306 @47 +@314 := @263 @271 +@315 := @132 @314 +@317 := (hs : @277) -> @315 @309 +@318 := @313 @275 +@319 := @132 @62 +@320 := @319 @309 +@321 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.__fits_0 +@326 := @324 @4 @15 +@330 := @5 (Coverage.Main.higher @4 @15) +@333 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.root @4 @15 +@334 := Bool +@335 := Ne.{1} +@336 := LexLeanPreservation.Obs +@337 := @335 @336 +@338 := LexLeanPreservation.Rel +@341 := @337 (@338 @15 @17) +@342 := LexLeanPreservation.Obs.stuck +@345 := (f : @334) -> (v : @54) -> @341 @342 +@347 := LexLeanPreservation.Rust.rel_ne_stuck @326 +@354 := (v : @54) -> @337 (@338 (@324 @12 @4) @17) @342 +@355 := @347 @330 +@359 := @337 (@338 @326 @330) @342 +@360 := @135 @65 +@361 := LexLeanPreservation.Rust.FunSem +@362 := #9 +@368 := (n : @3) -> @361 @362 @152 @146 @17 @138 +@369 := Eq.{1} +@370 := Option.{0} +@371 := @370 @82 +@372 := @369 @371 +@379 := LexLeanRuntime.index (@135 @82) @82 (LexLeanRuntime.instIndexableList @82) +@383 := @372 (@379 (@83 @362) @138) +@384 := Option.some.{0} +@385 := @384 @82 +@386 := @385 @140 +@387 := @383 @386 +@388 := #10 +@392 := @107 @388 @362 @152 @140 +@393 := LexLeanTarget.TargetSyntax.Function.types +@394 := @393 @138 +@395 := @392 @394 +@396 := @370 @360 +@397 := @369 @396 +@398 := LexLeanTarget.TargetSemantics.bindAll +@399 := LexLeanTarget.TargetSyntax.Function.parameters +@404 := @397 (@398 (@399 @146) @138 @75) +@405 := @384 @360 +@406 := @405 @140 +@407 := @404 @406 +@408 := @370 @334 +@409 := @369 @408 +@410 := LexLeanPreservation.Rust.fnFallible +@411 := #11 +@414 := @409 (@410 @411 @362) +@415 := @384 @334 +@416 := @415 @140 +@417 := @414 @416 +@418 := LexLeanPreservation.RunConv +@419 := #13 +@423 := @418 @419 @388 @152 @140 +@425 := @337 @138 @342 +@426 := Exists.{1} +@427 := LexLeanPreservation.Rust.ROut +@428 := @426 @427 +@429 := And +@430 := LexLeanPreservation.Rust.RealizesFn +@434 := @429 (@430 @362 @152 @17) +@435 := LexLeanPreservation.Rust.RCI +@437 := @435 #15 +@438 := LexLeanPreservation.Rust.fnIdent +@439 := @438 @419 +@446 := (hne : @425) -> @428 (fun (ro : @427) => @434 (@437 @439 @411 @17)) +@461 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @368) -> + (hfn : @387) -> (hwt : @395) -> (hbind : @407) -> (hF : @417) -> (hA : @423) -> @446 +@463 := LexLeanPreservation.Rust.compose @0 +@464 := @361 @0 +@469 := (n : @3) -> @464 @152 @146 @17 @138 +@470 := @379 @84 +@473 := @372 (@470 @138) @386 +@477 := @118 @362 @152 @140 @394 +@478 := @418 @0 +@481 := @478 @388 @152 @140 +@495 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @469) -> + (hfn : @473) -> (hwt : @477) -> (hbind : @407) -> (hF : @417) -> (hA : @481) -> @446 +@496 := @463 @1 +@497 := @464 @1 +@501 := (n : @3) -> @497 @146 @17 @138 +@504 := @126 @152 @140 @394 +@505 := @410 @1 +@508 := @409 (@505 @362) @416 +@509 := @435 @1 +@519 := (hbind : @407) -> + (hF : @508) -> (hA : @481) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@509 @439 @411 @17)) +@529 := {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> {F : @334} -> {o : @336} -> (hB : @501) -> (hfn : @473) -> (hwt : @504) -> @519 +@530 := @496 @2 +@532 := @497 @2 @17 +@534 := (n : @3) -> @532 @138 +@535 := @132 @140 +@536 := @535 @394 +@545 := {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @360} -> {F : @334} -> {o : @336} -> (hB : @534) -> (hfn : @473) -> (hwt : @536) -> @519 +@546 := @530 @72 +@548 := (n : @3) -> @532 @72 +@549 := @470 @72 +@550 := @372 @549 +@551 := @550 @386 +@552 := @505 @72 +@553 := @409 @552 +@554 := @553 @416 +@555 := @478 @72 +@557 := @555 @152 @140 +@559 := @509 (@438 @72) +@567 := (hF : @554) -> (hA : @557) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 @411 @17)) +@576 := {fn : @82} -> + {args : @136} -> + {env : @360} -> + {F : @334} -> {o : @336} -> (hB : @548) -> (hfn : @551) -> (hwt : @536) -> (hbind : @407) -> @567 +@577 := @546 @102 +@579 := @550 (@385 @102) +@580 := @393 @102 +@581 := @535 @580 +@583 := @398 (@399 @102) +@595 := {args : @136} -> + {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @548) -> (hfn : @579) -> (hwt : @581) -> (hbind : @397 (@583 @138 @75) @406) -> @567 +@596 := @577 @62 +@598 := @282 (@229 @57) +@600 := @132 @598 @580 +@602 := @58 (@5 @152) +@604 := @602 (@282 @57) +@608 := @397 (@583 @604 @75) @406 +@610 := @58 (@5 @388) +@612 := @58 (@5 @362) +@614 := @610 (@612 @57) +@616 := @555 @614 @140 +@618 := @58 (@5 @419) +@621 := @58 (@5 #12) +@638 := {env : @360} -> + {F : @334} -> + {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @600) -> + (hbind : @608) -> + (hF : @554) -> + (hA : @616) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 (@618 (@621 @57)) @17)) +@639 := @596 @80 +@641 := @229 (@243 @57) +@643 := @132 @641 @580 +@654 := @397 (@583 @598 @75) (@405 (@76 (@70 @228) (@76 (@73 @281) @75))) +@656 := @612 (@602 @57) +@658 := @555 @656 @140 +@660 := @58 (@5 @411) +@676 := {F : @334} -> + {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @643) -> + (hbind : @654) -> + (hF : @554) -> + (hA : @658) -> (hne : @425) -> @428 (fun (ro : @427) => @434 (@559 (@621 (@660 @57)) @17)) +@677 := @639 @81 +@678 := @301 @580 +@689 := @397 (@583 @641 @75) (@405 (@76 (@70 @242) (@76 (@73 @228) @75))) +@691 := @553 (@415 @81) +@693 := @555 @604 @140 +@694 := @430 @81 +@712 := {o : @336} -> + (hB : @548) -> + (hfn : @579) -> + (hwt : @678) -> + (hbind : @689) -> + (hF : @691) -> + (hA : @693) -> + (hne : @425) -> @428 (fun (ro : @427) => @429 (@694 @152 @17) (@559 (@660 (@610 @57)) @17)) +@713 := @677 @323 +@714 := @308 @580 +@725 := @397 (@583 @300 @75) (@405 (@76 (@70 @225) (@76 (@73 @242) @75))) +@726 := @555 @598 +@728 := @321 @146 @138 +@729 := @726 @728 +@731 := @321 @152 @146 +@750 := (hB : @548) -> + (hfn : @579) -> + (hwt : @714) -> + (hbind : @725) -> + (hF : @691) -> + (hA : @729) -> + (hne : @337 @731 @342) -> + @428 (fun (ro : @427) => @429 (@694 (@321 @388 @362) @17) (@559 @614 @17)) +@751 := @713 @106 +@752 := @315 @580 +@763 := @397 (@583 @307 @75) (@405 (@76 (@70 @239) (@76 (@73 @225) @75))) +@764 := @555 @641 +@766 := @321 @138 @140 +@785 := (hfn : @579) -> + (hwt : @752) -> + (hbind : @763) -> + (hF : @691) -> + (hA : @764 @766) -> + (hne : @337 @728 @342) -> + @428 (fun (ro : @427) => @429 (@694 (@321 @362 @152) @17) (@559 @656 @17)) +@786 := Eq.refl.{1} +@789 := @751 (@786 @371 @549) +@790 := @319 @580 +@801 := @397 (@583 @314 @75) (@405 (@76 (@70 @6) (@76 (@73 @239) @75))) +@802 := @555 @300 +@804 := @321 @140 @142 +@820 := (hwt : @790) -> + (hbind : @801) -> + (hF : @691) -> + (hA : @802 @804) -> + (hne : @337 @766 @342) -> @428 (fun (ro : @427) => @429 (@694 @731 @17) (@559 @604 @17)) +@821 := @789 @318 +@823 := @583 @62 @75 +@826 := @397 @823 (@405 @80) +@827 := @555 @307 +@829 := @321 @142 @12 +@844 := (hbind : @826) -> + (hF : @691) -> + (hA : @827 @829) -> + (hne : @337 @804 @342) -> @428 (fun (ro : @427) => @429 (@694 @728 @17) (@559 @598 @17)) +@847 := @821 (@786 @396 @823) +@848 := @555 @314 +@850 := @321 @12 @4 +@864 := (hF : @691) -> + (hA : @848 @850) -> + (hne : @337 @829 @342) -> @428 (fun (ro : @427) => @429 (@694 @766 @17) (@559 @641 @17)) +@867 := @847 (@786 @408 @552) +@881 := (hA : @555 @62 @323) -> + (hne : @337 @850 @342) -> @428 (fun (ro : @427) => @429 (@694 @804 @17) (@559 @300 @17)) +@882 := @867 @333 +@893 := (hne : @337 @323 @342) -> @428 (fun (ro : @427) => @429 (@694 @829 @17) (@559 @307 @17)) +@894 := @882 @355 +@900 := @429 (@694 @850 @17) (@559 @314 @17) +@902 := @428 (fun (ro : @427) => @900) +@904 := @428 (fun (__e_ro : @427) => @900) +@909 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@910 := (__e_hrep : @909) -> @904 +@911 := fun (__e_hrep : @909) => @894 +@912 := (offset : @3) -> @910 +@913 := fun (offset : @3) => @911 +@914 := (base : @3) -> @912 +@915 := fun (base : @3) => @913 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R19/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R19/Compose/RustStd.lean deleted file mode 100644 index 13292cb09..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R19/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (values : (List Nat)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) values)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.denote values) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) values)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat) values) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.root values) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R19/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R19/Compose/RustStd.lex.tex new file mode 100644 index 000000000..2ae236e94 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R19/Compose/RustStd.lex.tex @@ -0,0 +1,463 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd.root : @926 := @927 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd.flags +@3 := Nat +@4 := List.{0} +@5 := @4 @3 +@6 := #1 +@7 := LexLeanTarget.TargetSyntax.Value.nat +@8 := LexLeanPreservation.encList +@9 := @8 @3 +@10 := @9 @7 +@11 := @10 @6 +@12 := LexLeanTarget.TargetSyntax.Ty.nat +@13 := LexLeanTarget.TargetSyntax.Ty.list +@14 := @13 @12 +@15 := #0 +@16 := LexLeanTarget.TargetSyntax.Program +@17 := LexLeanPreservation.Rust.RCrate +@18 := LexLeanPreservation.Rust.Flags +@19 := LexLeanPreservation.Rust.WT +@20 := #3 +@21 := @19 @20 +@22 := #2 +@24 := @21 @22 @6 +@25 := @7 @15 +@31 := {p : @16} -> {c : @17} -> {A : @18} -> (n : @3) -> @24 @25 @12 +@33 := LexLeanPreservation.Rust.wt_nat @0 +@34 := @19 @0 +@41 := {c : @17} -> {A : @18} -> (n : @3) -> @34 @22 @6 @25 @12 +@42 := @33 @1 +@43 := @34 @1 +@48 := {A : @18} -> (n : @3) -> @43 @6 @25 @12 +@49 := @42 @2 +@50 := @43 @2 +@51 := @50 @25 +@52 := @51 @12 +@53 := (n : @3) -> @52 +@55 := fun (__x : @3) => @49 @15 +@56 := Sort 1 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := (a._@._internal._hyg.#0 : @15) -> @57 +@59 := LexLeanTarget.TargetSyntax.Ty +@60 := #6 +@61 := @19 @60 +@62 := #5 +@63 := @61 @62 +@64 := #4 +@65 := @63 @64 +@66 := @22 @15 +@69 := (x : @22) -> @65 @66 @6 +@70 := @4 @20 +@71 := #7 +@74 := @19 @71 @60 @62 +@77 := @8 @64 @20 @15 +@78 := @74 @77 +@79 := @13 @22 +@88 := {p : @16} -> + {c : @17} -> + {A : @18} -> {α : @56} -> {e : @58} -> {t : @59} -> (h : @69) -> (xs : @70) -> @78 @79 +@90 := LexLeanPreservation.Rust.wt_encList @0 +@92 := @34 @62 @64 +@106 := {c : @17} -> + {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @22) -> @92 @66 @6) -> (xs : @70) -> @34 @60 @62 @77 @79 +@107 := @90 @1 +@108 := @43 @64 +@120 := {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @22) -> @108 @66 @6) -> (xs : @70) -> @43 @62 @77 @79 +@121 := @107 @2 +@123 := @50 @66 @6 +@131 := {α : @56} -> {e : @58} -> {t : @59} -> (h : (x : @22) -> @123) -> (xs : @70) -> @50 @77 @79 +@132 := @121 @3 +@142 := {e : (a._@._internal._hyg.#0 : @3) -> @57} -> + {t : @59} -> (h : (x : @3) -> @123) -> (xs : @5) -> @50 (@9 @20 @15) @79 +@143 := @132 @7 +@145 := (x : @3) -> @51 @6 +@146 := @10 @15 +@147 := @50 @146 +@151 := {t : @59} -> (h : @145) -> (xs : @5) -> @147 @79 +@152 := @143 @12 +@156 := (h : (x : @3) -> @52) -> (xs : @5) -> @147 @14 +@158 := @152 @55 @6 +@160 := @50 @11 @14 +@161 := List.nil.{0} +@162 := List.cons.{0} +@163 := @161 @57 +@164 := @162 @57 +@166 := @164 @11 @163 +@169 := Prod.{0, 0} @3 @57 +@170 := 0 +@174 := Prod.mk.{0, 0} @3 @57 @170 +@175 := @174 @11 +@176 := @161 @169 +@177 := @162 @169 +@179 := @177 @175 @176 +@180 := Bool.false +@181 := LexLeanTarget.TargetSyntax.Function +@182 := LexLeanTarget.TargetSyntax.Program.functions +@183 := @182 @0 +@184 := @161 @3 +@185 := @161 @59 +@186 := LexLeanTarget.TargetSyntax.Ty.unit +@187 := LexLeanTarget.TargetSyntax.Value.unit +@190 := LexLeanTarget.TargetSyntax.Expr.value @186 @187 +@195 := LexLeanTarget.TargetSyntax.Function.mk @184 @185 @186 @190 +@200 := List.getD.{0} @181 @183 @170 @195 +@204 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd.root @15 @170 +@205 := LexLeanPreservation.Rust.WTL +@213 := {p : @16} -> {c : @17} -> {A : @18} -> @205 @22 @6 @15 @163 @185 +@215 := LexLeanPreservation.Rust.wtl_nil @0 +@216 := @205 @0 +@222 := {c : @17} -> {A : @18} -> @216 @6 @15 @163 @185 +@223 := @215 @1 +@224 := @216 @1 +@228 := {A : @18} -> @224 @15 @163 @185 +@229 := @223 @2 +@230 := @224 @2 +@231 := @230 @163 +@232 := @231 @185 +@233 := @4 @57 +@234 := @4 @59 +@236 := @65 @20 @22 +@241 := @205 @71 @60 @62 @22 @6 +@242 := #8 +@245 := @205 @242 @71 @60 +@247 := @164 @62 @20 +@248 := @245 @247 +@249 := @162 @59 +@251 := @249 @64 @22 +@261 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {v : @57} -> {t : @59} -> {vs : @233} -> {ts : @234} -> (h : @236) -> (hs : @241) -> @248 @251 +@263 := LexLeanPreservation.Rust.wtl_cons @0 +@281 := {c : @17} -> + {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @233} -> + {ts : @234} -> (h : @92 @20 @22) -> (hs : @216 @60 @62 @22 @6) -> @216 @71 @60 @247 @251 +@282 := @263 @1 +@297 := {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @233} -> {ts : @234} -> (h : @108 @20 @22) -> (hs : @224 @62 @22 @6) -> @224 @60 @247 @251 +@298 := @282 @2 +@300 := @50 @20 @22 +@302 := @230 @22 @6 +@310 := {v : @57} -> + {t : @59} -> {vs : @233} -> {ts : @234} -> (h : @300) -> (hs : @302) -> @230 @247 @251 +@311 := @298 @11 +@312 := @10 @64 +@314 := @50 @312 @22 +@315 := @10 @60 +@316 := @164 @315 +@324 := {t : @59} -> {vs : @233} -> {ts : @234} -> (h : @314) -> (hs : @302) -> @230 (@316 @20) @251 +@325 := @311 @14 +@326 := @10 @20 +@328 := @50 @326 @14 +@329 := @10 @62 +@330 := @164 @329 +@332 := @230 (@330 @20) +@333 := @249 @14 +@334 := @333 @22 +@339 := {vs : @233} -> {ts : @234} -> (h : @328) -> (hs : @302) -> @332 @334 +@340 := @325 @163 +@341 := @10 @22 +@343 := @50 @341 @14 +@344 := @231 @6 +@346 := @164 @312 @163 +@347 := @230 @346 +@351 := {ts : @234} -> (h : @343) -> (hs : @344) -> @347 @334 +@352 := @340 @185 +@354 := @164 @326 @163 +@355 := @230 @354 +@356 := @333 @185 +@359 := (h : @160) -> (hs : @232) -> @355 @356 +@360 := @352 @158 +@362 := @164 @341 @163 +@363 := @230 @362 +@365 := (hs : @232) -> @363 @356 +@366 := @360 @229 +@367 := @230 @166 +@368 := @367 @356 +@369 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.denote +@370 := @369 @6 +@371 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.__fits_0 +@372 := @371 @6 +@374 := Coverage.Main.mapped @6 +@375 := Bool +@376 := LexLeanTarget.TargetSyntax.Value.bool +@379 := @8 @375 @376 @374 +@381 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.root @6 +@382 := Ne.{1} +@383 := LexLeanPreservation.Obs +@384 := @382 @383 +@385 := LexLeanPreservation.Rel +@388 := @384 (@385 @6 @15) +@389 := LexLeanPreservation.Obs.stuck +@392 := (f : @375) -> (v : @57) -> @388 @389 +@394 := LexLeanPreservation.Rust.rel_ne_stuck @372 +@400 := (v : @57) -> @384 (@385 (@371 @22) @15) @389 +@401 := @394 @379 +@405 := @384 (@385 @372 @379) @389 +@406 := @4 @169 +@407 := LexLeanPreservation.Rust.FunSem +@408 := #9 +@414 := (n : @3) -> @407 @408 @242 @71 @15 @60 +@415 := Eq.{1} +@416 := Option.{0} +@417 := @416 @181 +@418 := @415 @417 +@425 := LexLeanRuntime.index (@4 @181) @181 (LexLeanRuntime.instIndexableList @181) +@429 := @418 (@425 (@182 @408) @60) +@430 := Option.some.{0} +@431 := @430 @181 +@432 := @431 @62 +@433 := @429 @432 +@434 := #10 +@438 := @205 @434 @408 @242 @62 +@439 := LexLeanTarget.TargetSyntax.Function.types +@440 := @439 @60 +@441 := @438 @440 +@442 := @416 @406 +@443 := @415 @442 +@444 := LexLeanTarget.TargetSemantics.bindAll +@445 := LexLeanTarget.TargetSyntax.Function.parameters +@450 := @443 (@444 (@445 @71) @60 @176) +@451 := @430 @406 +@452 := @451 @62 +@453 := @450 @452 +@454 := @416 @375 +@455 := @415 @454 +@456 := LexLeanPreservation.Rust.fnFallible +@457 := #11 +@460 := @455 (@456 @457 @408) +@461 := @430 @375 +@462 := @461 @62 +@463 := @460 @462 +@464 := LexLeanPreservation.RunConv +@465 := #13 +@469 := @464 @465 @434 @242 @62 +@471 := @384 @60 @389 +@472 := Exists.{1} +@473 := LexLeanPreservation.Rust.ROut +@474 := @472 @473 +@475 := And +@476 := LexLeanPreservation.Rust.RealizesFn +@480 := @475 (@476 @408 @242 @15) +@481 := LexLeanPreservation.Rust.RCI +@483 := @481 #15 +@484 := LexLeanPreservation.Rust.fnIdent +@485 := @484 @465 +@492 := (hne : @471) -> @474 (fun (ro : @473) => @480 (@483 @485 @457 @15)) +@507 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @406} -> + {F : @375} -> + {o : @383} -> + (hB : @414) -> + (hfn : @433) -> (hwt : @441) -> (hbind : @453) -> (hF : @463) -> (hA : @469) -> @492 +@509 := LexLeanPreservation.Rust.compose @0 +@510 := @407 @0 +@515 := (n : @3) -> @510 @242 @71 @15 @60 +@516 := @425 @183 +@519 := @418 (@516 @60) @432 +@523 := @216 @408 @242 @62 @440 +@524 := @464 @0 +@527 := @524 @434 @242 @62 +@541 := {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @406} -> + {F : @375} -> + {o : @383} -> + (hB : @515) -> + (hfn : @519) -> (hwt : @523) -> (hbind : @453) -> (hF : @463) -> (hA : @527) -> @492 +@542 := @509 @1 +@543 := @510 @1 +@547 := (n : @3) -> @543 @71 @15 @60 +@550 := @224 @242 @62 @440 +@551 := @456 @1 +@554 := @455 (@551 @408) @462 +@555 := @481 @1 +@565 := (hbind : @453) -> + (hF : @554) -> (hA : @527) -> (hne : @471) -> @474 (fun (ro : @473) => @480 (@555 @485 @457 @15)) +@575 := {A : @18} -> + {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @406} -> {F : @375} -> {o : @383} -> (hB : @547) -> (hfn : @519) -> (hwt : @550) -> @565 +@576 := @542 @2 +@578 := @543 @2 @15 +@580 := (n : @3) -> @578 @60 +@581 := @230 @62 +@582 := @581 @440 +@591 := {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @406} -> {F : @375} -> {o : @383} -> (hB : @580) -> (hfn : @519) -> (hwt : @582) -> @565 +@592 := @576 @170 +@594 := (n : @3) -> @578 @170 +@595 := @516 @170 +@596 := @418 @595 +@597 := @596 @432 +@598 := @551 @170 +@599 := @455 @598 +@600 := @599 @462 +@601 := @524 @170 +@603 := @601 @242 @62 +@605 := @555 (@484 @170) +@613 := (hF : @600) -> (hA : @603) -> (hne : @471) -> @474 (fun (ro : @473) => @480 (@605 @457 @15)) +@622 := {fn : @181} -> + {args : @233} -> + {env : @406} -> + {F : @375} -> {o : @383} -> (hB : @594) -> (hfn : @597) -> (hwt : @582) -> (hbind : @453) -> @613 +@623 := @592 @200 +@625 := @596 (@431 @200) +@626 := @439 @200 +@627 := @581 @626 +@629 := @444 (@445 @200) +@641 := {args : @233} -> + {env : @406} -> + {F : @375} -> + {o : @383} -> + (hB : @594) -> (hfn : @625) -> (hwt : @627) -> (hbind : @443 (@629 @60 @176) @452) -> @613 +@642 := @623 @166 +@643 := @316 @163 +@645 := @230 @643 @626 +@648 := @164 (@10 @71) @163 +@652 := @443 (@629 @648 @176) @452 +@655 := @164 (@10 @408) @163 +@676 := {env : @406} -> + {F : @375} -> + {o : @383} -> + (hB : @594) -> + (hfn : @625) -> + (hwt : @645) -> + (hbind : @652) -> + (hF : @600) -> + (hA : @601 @655 @62) -> + (hne : @471) -> @474 (fun (ro : @473) => @480 (@605 (@164 (@10 #12) @163) @15)) +@677 := @642 @179 +@678 := @330 @163 +@680 := @230 @678 @626 +@688 := @443 (@629 @643 @176) (@451 (@177 (@174 @315) @176)) +@691 := @164 (@10 @242) @163 +@710 := {F : @375} -> + {o : @383} -> + (hB : @594) -> + (hfn : @625) -> + (hwt : @680) -> + (hbind : @688) -> + (hF : @600) -> + (hA : @601 @691 @62) -> + (hne : @471) -> @474 (fun (ro : @473) => @480 (@605 (@164 (@10 @457) @163) @15)) +@711 := @677 @180 +@712 := @347 @626 +@720 := @443 (@629 @678 @176) (@451 (@177 (@174 @329) @176)) +@722 := @599 (@461 @180) +@724 := @601 @648 @62 +@725 := @476 @180 +@744 := {o : @383} -> + (hB : @594) -> + (hfn : @625) -> + (hwt : @712) -> + (hbind : @720) -> + (hF : @722) -> + (hA : @724) -> + (hne : @471) -> @474 (fun (ro : @473) => @475 (@725 @242 @15) (@605 (@164 (@10 @434) @163) @15)) +@745 := @711 @370 +@746 := @355 @626 +@754 := @443 (@629 @346 @176) (@451 (@177 (@174 @312) @176)) +@755 := @601 @643 +@756 := @369 @60 +@757 := @755 @756 +@758 := @369 @71 +@776 := (hB : @594) -> + (hfn : @625) -> + (hwt : @746) -> + (hbind : @754) -> + (hF : @722) -> + (hA : @757) -> + (hne : @384 @758 @389) -> @474 (fun (ro : @473) => @475 (@725 (@369 @408) @15) (@605 @655 @15)) +@777 := @745 @204 +@778 := @363 @626 +@786 := @443 (@629 @354 @176) (@451 (@177 (@174 @326) @176)) +@787 := @601 @678 +@788 := @369 @62 +@806 := (hfn : @625) -> + (hwt : @778) -> + (hbind : @786) -> + (hF : @722) -> + (hA : @787 @788) -> + (hne : @384 @756 @389) -> @474 (fun (ro : @473) => @475 (@725 (@369 @242) @15) (@605 @691 @15)) +@807 := Eq.refl.{1} +@810 := @777 (@807 @417 @595) +@811 := @367 @626 +@819 := @443 (@629 @362 @176) (@451 (@177 (@174 @341) @176)) +@820 := @601 @346 +@821 := @369 @64 +@837 := (hwt : @811) -> + (hbind : @819) -> + (hF : @722) -> + (hA : @820 @821) -> + (hne : @384 @788 @389) -> @474 (fun (ro : @473) => @475 (@725 @758 @15) (@605 @648 @15)) +@838 := @810 @366 +@840 := @629 @166 @176 +@843 := @443 @840 (@451 @179) +@844 := @601 @354 +@845 := @369 @20 +@860 := (hbind : @843) -> + (hF : @722) -> + (hA : @844 @845) -> + (hne : @384 @821 @389) -> @474 (fun (ro : @473) => @475 (@725 @756 @15) (@605 @643 @15)) +@863 := @838 (@807 @442 @840) +@864 := @601 @362 +@865 := @369 @22 +@879 := (hF : @722) -> + (hA : @864 @865) -> + (hne : @384 @845 @389) -> @474 (fun (ro : @473) => @475 (@725 @788 @15) (@605 @678 @15)) +@882 := @863 (@807 @454 @598) +@896 := (hA : @601 @166 @370) -> + (hne : @384 @865 @389) -> @474 (fun (ro : @473) => @475 (@725 @821 @15) (@605 @346 @15)) +@897 := @882 @381 +@908 := (hne : @384 @370 @389) -> @474 (fun (ro : @473) => @475 (@725 @845 @15) (@605 @354 @15)) +@909 := @897 @401 +@915 := @475 (@725 @865 @15) (@605 @362 @15) +@917 := @474 (fun (ro : @473) => @915) +@919 := @474 (fun (__e_ro : @473) => @915) +@923 := LexLeanPreservation.Rust.RepresentableL (@164 @146 @163) +@924 := (__e_hrep : @923) -> @919 +@925 := fun (__e_hrep : @923) => @909 +@926 := (values : @5) -> @924 +@927 := fun (values : @5) => @925 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R2/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R2/Compose/RustStd.lean deleted file mode 100644 index 3ca11a1a6..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R2/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd - -/-- The rendering of the root's entry, invoked on the encoded arguments, -realizes the encoded source result when the arguments satisfy §17.12's -invariants, and refuses them with `none` otherwise. -/ -theorem root (m : (List (Prod Nat Nat))) (bonus : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.nat)) m), (_root_.LexLeanTarget.TargetSyntax.Value.nat bonus)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 5) [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.nat)) m), (_root_.LexLeanTarget.TargetSyntax.Value.nat bonus)] __e_ro ∧ - (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.accepts m bonus → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.denote m bonus)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.accepts m bonus → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none) __e_ro) := - match _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd.root __e_n 5) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_nat)) m) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat bonus) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.entry m bonus) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) with - | ⟨__e_ro, __e_hr, __e_hc⟩ => ⟨__e_ro, __e_hc, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.entry_accepts m bonus __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.entry_refuses m bonus __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R2/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R2/Compose/RustStd.lex.tex new file mode 100644 index 000000000..57b6c0180 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R2/Compose/RustStd.lex.tex @@ -0,0 +1,658 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd.root : @1352 := @1353 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd.flags +@3 := Nat +@4 := Prod.{0, 0} +@5 := @4 @3 +@6 := @5 @3 +@7 := List.{0} +@8 := @7 @6 +@9 := #2 +@10 := LexLeanTarget.TargetSyntax.Value.nat +@11 := LexLeanPreservation.encPair +@12 := @11 @3 +@13 := @12 @3 +@14 := @13 @10 +@15 := @14 @10 +@16 := LexLeanPreservation.encList +@17 := @16 @6 +@18 := @17 @15 +@19 := @18 @9 +@20 := LexLeanTarget.TargetSyntax.Ty.nat +@21 := LexLeanTarget.TargetSyntax.Ty.pair +@22 := @21 @20 +@23 := @22 @20 +@24 := LexLeanTarget.TargetSyntax.Ty.list +@25 := @24 @23 +@26 := #0 +@27 := LexLeanTarget.TargetSyntax.Program +@28 := LexLeanPreservation.Rust.RCrate +@29 := LexLeanPreservation.Rust.Flags +@30 := LexLeanPreservation.Rust.WT +@31 := #3 +@33 := @30 @31 @9 +@34 := #1 +@35 := @33 @34 +@36 := @10 @26 +@42 := {p : @27} -> {c : @28} -> {A : @29} -> (n : @3) -> @35 @36 @20 +@44 := LexLeanPreservation.Rust.wt_nat @0 +@45 := @30 @0 +@52 := {c : @28} -> {A : @29} -> (n : @3) -> @45 @9 @34 @36 @20 +@53 := @44 @1 +@54 := @45 @1 +@59 := {A : @29} -> (n : @3) -> @54 @34 @36 @20 +@60 := @53 @2 +@61 := @54 @2 +@62 := @61 @36 +@63 := @62 @20 +@64 := (n : @3) -> @63 +@66 := fun (__x : @3) => @60 @26 +@67 := Sort 1 +@68 := LexLeanTarget.TargetSyntax.Value +@69 := (a._@._internal._hyg.#0 : @34) -> @68 +@70 := LexLeanTarget.TargetSyntax.Ty +@71 := #5 +@72 := #9 +@73 := @30 @72 +@74 := #8 +@75 := @73 @74 +@76 := #7 +@77 := @75 @76 +@78 := #4 +@79 := @78 @26 +@82 := (x : @71) -> @77 @79 @9 +@83 := #10 +@89 := (x : @71) -> @30 @83 @72 @74 @79 @9 +@90 := @4 @76 +@91 := #6 +@92 := @90 @91 +@93 := #11 +@96 := @30 @93 @83 @72 +@101 := @11 @74 @76 @91 @71 @26 +@102 := @96 @101 +@104 := @21 @78 @31 +@117 := {p : @27} -> + {c : @28} -> + {A : @29} -> + {α : @67} -> + {β : @67} -> + {ea : @69} -> + {eb : @69} -> {s : @70} -> {t : @70} -> (ha : @82) -> (hb : @89) -> (x : @92) -> @102 @104 +@119 := LexLeanPreservation.Rust.wt_encPair @0 +@144 := {c : @28} -> + {A : @29} -> + {α : @67} -> + {β : @67} -> + {ea : @69} -> + {eb : @69} -> + {s : @70} -> + {t : @70} -> + (ha : (x : @71) -> @45 @74 @76 @79 @9) -> + (hb : (x : @71) -> @45 @72 @74 @79 @9) -> (x : @92) -> @45 @83 @72 @101 @104 +@145 := @119 @1 +@166 := {A : @29} -> + {α : @67} -> + {β : @67} -> + {ea : @69} -> + {eb : @69} -> + {s : @70} -> + {t : @70} -> + (ha : (x : @71) -> @54 @76 @79 @9) -> + (hb : (x : @71) -> @54 @74 @79 @9) -> (x : @92) -> @54 @72 @101 @104 +@167 := @145 @2 +@169 := @61 @79 @9 +@170 := (x : @71) -> @169 +@181 := {α : @67} -> + {β : @67} -> + {ea : @69} -> + {eb : @69} -> {s : @70} -> {t : @70} -> (ha : @170) -> (hb : @170) -> (x : @92) -> @61 @101 @104 +@182 := @167 @3 +@183 := (a._@._internal._hyg.#0 : @3) -> @68 +@184 := (x : @3) -> @169 +@199 := {β : @67} -> + {ea : @183} -> + {eb : @69} -> + {s : @70} -> + {t : @70} -> (ha : @184) -> (hb : @170) -> (x : @5 @91) -> @61 (@12 @76 @91 @71 @26) @104 +@200 := @182 @3 +@212 := {ea : @183} -> + {eb : @183} -> + {s : @70} -> {t : @70} -> (ha : @184) -> (hb : @184) -> (x : @6) -> @61 (@13 @91 @71 @26) @104 +@213 := @200 @10 +@215 := (x : @3) -> @62 @9 +@225 := {eb : @183} -> + {s : @70} -> {t : @70} -> (ha : @215) -> (hb : @184) -> (x : @6) -> @61 (@14 @71 @26) @104 +@226 := @213 @10 +@228 := @61 (@15 @26) +@234 := {s : @70} -> {t : @70} -> (ha : @215) -> (hb : @215) -> (x : @6) -> @228 @104 +@235 := @226 @20 +@236 := (x : @3) -> @63 +@242 := {t : @70} -> (ha : @236) -> (hb : @215) -> (x : @6) -> @228 (@22 @31) +@243 := @235 @20 +@245 := (x : @6) -> @228 @23 +@247 := (ha : @236) -> (hb : @236) -> @245 +@251 := fun (__x : @6) => @243 @66 @66 @26 +@252 := (a._@._internal._hyg.#0 : @26) -> @68 +@255 := @30 @91 @71 @78 +@256 := @9 @26 +@259 := (x : @9) -> @255 @256 @34 +@260 := @7 @31 +@263 := @30 @76 @91 @71 +@266 := @16 @78 @31 @26 +@267 := @263 @266 +@268 := @24 @9 +@277 := {p : @27} -> + {c : @28} -> + {A : @29} -> {α : @67} -> {e : @252} -> {t : @70} -> (h : @259) -> (xs : @260) -> @267 @268 +@279 := LexLeanPreservation.Rust.wt_encList @0 +@281 := @45 @71 @78 +@295 := {c : @28} -> + {A : @29} -> + {α : @67} -> + {e : @252} -> {t : @70} -> (h : (x : @9) -> @281 @256 @34) -> (xs : @260) -> @45 @91 @71 @266 @268 +@296 := @279 @1 +@297 := @54 @78 +@309 := {A : @29} -> + {α : @67} -> + {e : @252} -> {t : @70} -> (h : (x : @9) -> @297 @256 @34) -> (xs : @260) -> @54 @71 @266 @268 +@310 := @296 @2 +@312 := @61 @256 @34 +@320 := {α : @67} -> + {e : @252} -> {t : @70} -> (h : (x : @9) -> @312) -> (xs : @260) -> @61 @266 @268 +@321 := @310 @6 +@331 := {e : (a._@._internal._hyg.#0 : @6) -> @68} -> + {t : @70} -> (h : (x : @6) -> @312) -> (xs : @8) -> @61 (@17 @31 @26) @268 +@332 := @321 @15 +@334 := (x : @6) -> @228 @34 +@336 := @61 (@18 @26) +@340 := {t : @70} -> (h : @334) -> (xs : @8) -> @336 @268 +@341 := @332 @23 +@344 := (h : @245) -> (xs : @8) -> @336 @25 +@346 := @341 @251 @9 +@348 := @61 @19 @25 +@349 := @10 @34 +@350 := @60 @34 +@352 := @61 @349 @20 +@353 := List.nil.{0} +@354 := List.cons.{0} +@355 := @353 @68 +@356 := @354 @68 +@358 := @356 @349 @355 +@360 := @356 @19 @358 +@361 := @5 @68 +@362 := 1 +@365 := Prod.mk.{0, 0} @3 @68 +@366 := @365 @362 +@367 := @366 @349 +@369 := @365 0 +@370 := @369 @19 +@371 := @353 @361 +@372 := @354 @361 +@374 := @372 @370 @371 +@376 := @372 @367 @374 +@377 := Bool.true +@378 := LexLeanTarget.TargetSyntax.Function +@379 := LexLeanTarget.TargetSyntax.Program.functions +@380 := @379 @0 +@381 := 5 +@382 := @353 @3 +@383 := @353 @70 +@384 := LexLeanTarget.TargetSyntax.Ty.unit +@385 := LexLeanTarget.TargetSyntax.Value.unit +@388 := LexLeanTarget.TargetSyntax.Expr.value @384 @385 +@393 := LexLeanTarget.TargetSyntax.Function.mk @382 @383 @384 @388 +@398 := List.getD.{0} @378 @380 @381 @393 +@402 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd.root @26 @381 +@403 := LexLeanPreservation.Rust.WTL +@411 := {p : @27} -> {c : @28} -> {A : @29} -> @403 @9 @34 @26 @355 @383 +@413 := LexLeanPreservation.Rust.wtl_nil @0 +@414 := @403 @0 +@420 := {c : @28} -> {A : @29} -> @414 @34 @26 @355 @383 +@421 := @413 @1 +@422 := @414 @1 +@426 := {A : @29} -> @422 @26 @355 @383 +@427 := @421 @2 +@428 := @422 @2 +@429 := @428 @355 +@430 := @429 @383 +@431 := @7 @68 +@432 := @7 @70 +@434 := @255 @31 @9 +@439 := @403 @76 @91 @71 @9 @34 +@442 := @403 @74 @76 @91 +@444 := @356 @71 @31 +@445 := @442 @444 +@446 := @354 @70 +@448 := @446 @78 @9 +@458 := {p : @27} -> + {c : @28} -> + {A : @29} -> + {v : @68} -> {t : @70} -> {vs : @431} -> {ts : @432} -> (h : @434) -> (hs : @439) -> @445 @448 +@460 := LexLeanPreservation.Rust.wtl_cons @0 +@478 := {c : @28} -> + {A : @29} -> + {v : @68} -> + {t : @70} -> + {vs : @431} -> + {ts : @432} -> (h : @281 @31 @9) -> (hs : @414 @91 @71 @9 @34) -> @414 @76 @91 @444 @448 +@479 := @460 @1 +@494 := {A : @29} -> + {v : @68} -> + {t : @70} -> + {vs : @431} -> {ts : @432} -> (h : @297 @31 @9) -> (hs : @422 @71 @9 @34) -> @422 @91 @444 @448 +@495 := @479 @2 +@497 := @61 @31 @9 +@499 := @428 @9 @34 +@507 := {v : @68} -> + {t : @70} -> {vs : @431} -> {ts : @432} -> (h : @497) -> (hs : @499) -> @428 @444 @448 +@508 := @495 @349 +@509 := @10 @78 +@511 := @61 @509 @9 +@512 := @10 @91 +@513 := @356 @512 +@521 := {t : @70} -> {vs : @431} -> {ts : @432} -> (h : @511) -> (hs : @499) -> @428 (@513 @31) @448 +@522 := @508 @20 +@523 := @10 @31 +@525 := @61 @523 @20 +@526 := @10 @71 +@527 := @356 @526 +@529 := @428 (@527 @31) +@530 := @446 @20 +@531 := @530 @9 +@536 := {vs : @431} -> {ts : @432} -> (h : @525) -> (hs : @499) -> @529 @531 +@537 := @522 @355 +@538 := @10 @9 +@540 := @61 @538 @20 +@541 := @429 @34 +@543 := @356 @509 @355 +@548 := {ts : @432} -> (h : @540) -> (hs : @541) -> @428 @543 @531 +@549 := @537 @383 +@551 := @356 @523 @355 +@552 := @428 @551 +@553 := @530 @383 +@556 := (h : @352) -> (hs : @430) -> @552 @553 +@557 := @549 @350 +@559 := @356 @538 @355 +@561 := @428 @559 @553 +@562 := (hs : @430) -> @561 +@563 := @557 @427 +@565 := @428 @358 @553 +@566 := @495 @19 +@567 := @18 @71 +@569 := @61 @567 @9 +@570 := @18 @76 +@571 := @356 @570 +@579 := {t : @70} -> {vs : @431} -> {ts : @432} -> (h : @569) -> (hs : @499) -> @428 (@571 @31) @448 +@580 := @566 @25 +@581 := @18 @78 +@583 := @61 @581 @25 +@584 := @18 @91 +@585 := @356 @584 +@587 := @428 (@585 @31) +@588 := @446 @25 +@589 := @588 @9 +@594 := {vs : @431} -> {ts : @432} -> (h : @583) -> (hs : @499) -> @587 @589 +@595 := @580 @358 +@596 := @18 @31 +@598 := @61 @596 @25 +@599 := @552 @34 +@601 := @356 @567 @543 +@602 := @428 @601 +@606 := {ts : @432} -> (h : @598) -> (hs : @599) -> @602 @589 +@607 := @595 @553 +@609 := @356 @581 @551 +@610 := @428 @609 +@611 := @588 @553 +@614 := (h : @348) -> (hs : @561) -> @610 @611 +@615 := @607 @346 +@617 := @356 @596 @559 +@618 := @428 @617 +@620 := (hs : @565) -> @618 @611 +@621 := @615 @563 +@622 := @428 @360 +@623 := @622 @611 +@624 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.denoteEntry +@626 := @624 @9 @34 +@627 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.entryFits +@629 := @627 @9 @34 +@632 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.entryValue @9 @34 +@635 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.entry @9 @34 +@636 := Bool +@637 := Ne.{1} +@638 := LexLeanPreservation.Obs +@639 := @637 @638 +@640 := LexLeanPreservation.Rel +@643 := @639 (@640 @34 @26) +@644 := LexLeanPreservation.Obs.stuck +@647 := (f : @636) -> (v : @68) -> @643 @644 +@649 := LexLeanPreservation.Rust.rel_ne_stuck @629 +@656 := (v : @68) -> @639 (@640 (@627 @31 @9) @26) @644 +@657 := @649 @632 +@661 := @639 (@640 @629 @632) @644 +@662 := @7 @361 +@663 := LexLeanPreservation.Rust.FunSem +@669 := (n : @3) -> @663 @72 @74 @76 @26 @91 +@670 := Eq.{1} +@671 := Option.{0} +@672 := @671 @378 +@673 := @670 @672 +@680 := LexLeanRuntime.index (@7 @378) @378 (LexLeanRuntime.instIndexableList @378) +@684 := @673 (@680 (@379 @72) @91) +@685 := Option.some.{0} +@686 := @685 @378 +@687 := @686 @71 +@688 := @684 @687 +@692 := @403 @83 @72 @74 @71 +@693 := LexLeanTarget.TargetSyntax.Function.types +@694 := @693 @91 +@695 := @692 @694 +@696 := @671 @662 +@697 := @670 @696 +@698 := LexLeanTarget.TargetSemantics.bindAll +@699 := LexLeanTarget.TargetSyntax.Function.parameters +@704 := @697 (@698 (@699 @76) @91 @371) +@705 := @685 @662 +@706 := @705 @71 +@707 := @704 @706 +@708 := @671 @636 +@709 := @670 @708 +@710 := LexLeanPreservation.Rust.fnFallible +@713 := @709 (@710 @93 @72) +@714 := @685 @636 +@715 := @714 @71 +@716 := @713 @715 +@717 := LexLeanPreservation.RunConv +@718 := #13 +@722 := @717 @718 @83 @74 @71 +@724 := @639 @91 @644 +@725 := Exists.{1} +@726 := LexLeanPreservation.Rust.ROut +@727 := @725 @726 +@728 := And +@729 := LexLeanPreservation.Rust.RealizesFn +@733 := @728 (@729 @72 @74 @26) +@734 := LexLeanPreservation.Rust.RCI +@736 := @734 #15 +@737 := LexLeanPreservation.Rust.fnIdent +@738 := @737 @718 +@745 := (hne : @724) -> @727 (fun (ro : @726) => @733 (@736 @738 @93 @26)) +@760 := {p : @27} -> + {c : @28} -> + {A : @29} -> + {f : @3} -> + {fn : @378} -> + {args : @431} -> + {env : @662} -> + {F : @636} -> + {o : @638} -> + (hB : @669) -> + (hfn : @688) -> (hwt : @695) -> (hbind : @707) -> (hF : @716) -> (hA : @722) -> @745 +@762 := LexLeanPreservation.Rust.compose @0 +@763 := @663 @0 +@768 := (n : @3) -> @763 @74 @76 @26 @91 +@769 := @680 @380 +@772 := @673 (@769 @91) @687 +@776 := @414 @72 @74 @71 @694 +@777 := @717 @0 +@780 := @777 @83 @74 @71 +@794 := {c : @28} -> + {A : @29} -> + {f : @3} -> + {fn : @378} -> + {args : @431} -> + {env : @662} -> + {F : @636} -> + {o : @638} -> + (hB : @768) -> + (hfn : @772) -> (hwt : @776) -> (hbind : @707) -> (hF : @716) -> (hA : @780) -> @745 +@795 := @762 @1 +@796 := @763 @1 +@800 := (n : @3) -> @796 @76 @26 @91 +@803 := @422 @74 @71 @694 +@804 := @710 @1 +@807 := @709 (@804 @72) @715 +@808 := @734 @1 +@818 := (hbind : @707) -> + (hF : @807) -> (hA : @780) -> (hne : @724) -> @727 (fun (ro : @726) => @733 (@808 @738 @93 @26)) +@828 := {A : @29} -> + {f : @3} -> + {fn : @378} -> + {args : @431} -> + {env : @662} -> {F : @636} -> {o : @638} -> (hB : @800) -> (hfn : @772) -> (hwt : @803) -> @818 +@829 := @795 @2 +@831 := @796 @2 @26 +@833 := (n : @3) -> @831 @91 +@834 := @428 @71 +@835 := @834 @694 +@844 := {f : @3} -> + {fn : @378} -> + {args : @431} -> + {env : @662} -> {F : @636} -> {o : @638} -> (hB : @833) -> (hfn : @772) -> (hwt : @835) -> @818 +@845 := @829 @381 +@847 := (n : @3) -> @831 @381 +@848 := @769 @381 +@849 := @673 @848 +@850 := @849 @687 +@851 := @804 @381 +@852 := @709 @851 +@853 := @852 @715 +@854 := @777 @381 +@856 := @854 @74 @71 +@858 := @808 (@737 @381) +@866 := (hF : @853) -> (hA : @856) -> (hne : @724) -> @727 (fun (ro : @726) => @733 (@858 @93 @26)) +@875 := {fn : @378} -> + {args : @431} -> + {env : @662} -> + {F : @636} -> {o : @638} -> (hB : @847) -> (hfn : @850) -> (hwt : @835) -> (hbind : @707) -> @866 +@876 := @845 @398 +@878 := @849 (@686 @398) +@879 := @693 @398 +@880 := @834 @879 +@882 := @698 (@699 @398) +@894 := {args : @431} -> + {env : @662} -> + {F : @636} -> + {o : @638} -> + (hB : @847) -> (hfn : @878) -> (hwt : @880) -> (hbind : @697 (@882 @91 @371) @706) -> @866 +@895 := @876 @360 +@897 := @571 (@513 @355) +@899 := @428 @897 @879 +@905 := @356 (@18 @74) (@356 (@10 @76) @355) +@909 := @697 (@882 @905 @371) @706 +@915 := @356 (@18 @83) (@356 (@10 @72) @355) +@917 := @854 @915 @71 +@919 := @356 (@18 @718) +@920 := #12 +@939 := {env : @662} -> + {F : @636} -> + {o : @638} -> + (hB : @847) -> + (hfn : @878) -> + (hwt : @899) -> + (hbind : @909) -> + (hF : @853) -> + (hA : @917) -> + (hne : @724) -> @727 (fun (ro : @726) => @733 (@858 (@919 (@356 (@10 @920) @355)) @26)) +@940 := @895 @376 +@942 := @585 (@527 @355) +@944 := @428 @942 @879 +@955 := @697 (@882 @897 @371) (@705 (@372 (@366 @512) (@372 (@369 @570) @371))) +@961 := @356 (@18 @72) (@356 (@10 @74) @355) +@983 := {F : @636} -> + {o : @638} -> + (hB : @847) -> + (hfn : @878) -> + (hwt : @944) -> + (hbind : @955) -> + (hF : @853) -> + (hA : @854 @961 @71) -> + (hne : @724) -> @727 (fun (ro : @726) => @733 (@858 (@356 (@18 @920) (@356 (@10 @93) @355)) @26)) +@984 := @940 @377 +@985 := @602 @879 +@996 := @697 (@882 @942 @371) (@705 (@372 (@366 @526) (@372 (@369 @584) @371))) +@998 := @852 (@714 @377) +@1000 := @854 @905 @71 +@1001 := @729 @377 +@1023 := {o : @638} -> + (hB : @847) -> + (hfn : @878) -> + (hwt : @985) -> + (hbind : @996) -> + (hF : @998) -> + (hA : @1000) -> + (hne : @724) -> + @727 (fun (ro : @726) => @728 (@1001 @74 @26) (@858 (@356 (@18 @93) (@356 (@10 @83) @355)) @26)) +@1024 := @984 @626 +@1025 := @610 @879 +@1036 := @697 (@882 @601 @371) (@705 (@372 (@366 @509) (@372 (@369 @567) @371))) +@1037 := @854 @897 +@1039 := @624 @76 @91 +@1040 := @1037 @1039 +@1042 := @624 @74 @76 +@1061 := (hB : @847) -> + (hfn : @878) -> + (hwt : @1025) -> + (hbind : @1036) -> + (hF : @998) -> + (hA : @1040) -> + (hne : @639 @1042 @644) -> + @727 (fun (ro : @726) => @728 (@1001 (@624 @83 @72) @26) (@858 @915 @26)) +@1062 := @1024 @402 +@1063 := @618 @879 +@1074 := @697 (@882 @609 @371) (@705 (@372 (@366 @523) (@372 (@369 @581) @371))) +@1075 := @854 @942 +@1077 := @624 @91 @71 +@1096 := (hfn : @878) -> + (hwt : @1063) -> + (hbind : @1074) -> + (hF : @998) -> + (hA : @1075 @1077) -> + (hne : @639 @1039 @644) -> + @727 (fun (ro : @726) => @728 (@1001 (@624 @72 @74) @26) (@858 @961 @26)) +@1097 := Eq.refl.{1} +@1100 := @1062 (@1097 @672 @848) +@1101 := @622 @879 +@1112 := @697 (@882 @617 @371) (@705 (@372 (@366 @538) (@372 (@369 @596) @371))) +@1113 := @854 @601 +@1115 := @624 @71 @78 +@1131 := (hwt : @1101) -> + (hbind : @1112) -> + (hF : @998) -> + (hA : @1113 @1115) -> + (hne : @639 @1077 @644) -> @727 (fun (ro : @726) => @728 (@1001 @1042 @26) (@858 @905 @26)) +@1132 := @1100 @621 +@1134 := @882 @360 @371 +@1137 := @697 @1134 (@705 @376) +@1138 := @854 @609 +@1140 := @624 @78 @31 +@1155 := (hbind : @1137) -> + (hF : @998) -> + (hA : @1138 @1140) -> + (hne : @639 @1115 @644) -> @727 (fun (ro : @726) => @728 (@1001 @1039 @26) (@858 @897 @26)) +@1158 := @1132 (@1097 @696 @1134) +@1159 := @854 @617 +@1161 := @624 @31 @9 +@1175 := (hF : @998) -> + (hA : @1159 @1161) -> + (hne : @639 @1140 @644) -> @727 (fun (ro : @726) => @728 (@1001 @1077 @26) (@858 @942 @26)) +@1178 := @1158 (@1097 @708 @851) +@1180 := @854 @360 @626 +@1182 := @639 @1161 @644 +@1183 := @1001 @1115 +@1185 := @728 (@1183 @26) +@1186 := @858 @601 +@1187 := @1186 @26 +@1192 := (hA : @1180) -> (hne : @1182) -> @727 (fun (ro : @726) => @1185 @1187) +@1193 := @1178 @635 +@1195 := @639 @626 @644 +@1196 := @1001 @1140 +@1198 := @728 (@1196 @26) +@1199 := @858 @609 +@1204 := (hne : @1195) -> @727 (fun (ro : @726) => @1198 (@1199 @26)) +@1205 := @1193 @657 +@1208 := @728 (@1001 @1161 @26) +@1210 := @858 @617 @26 +@1211 := @1208 @1210 +@1213 := @727 (fun (ro : @726) => @1211) +@1214 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.accepts +@1216 := @1214 @9 @34 +@1217 := LexLeanPreservation.someObs +@1218 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.denote +@1221 := @1217 (@1218 @9 @34) +@1224 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none +@1225 := Not +@1226 := @1225 @1216 +@1228 := @1214 @31 @9 +@1231 := @1217 (@1218 @31 @9) +@1232 := @1225 @1228 +@1238 := @1228 -> @1001 (@1217 (@1218 @78 @31)) @34 +@1239 := @1001 @1224 +@1240 := @1239 @34 +@1241 := @1232 -> @1240 +@1243 := @728 @1238 @1241 +@1247 := @727 (fun (__e_ro : @726) => @728 @1210 @1243) +@1248 := fun (__e_ro : @726) => @1211 +@1249 := @1196 @34 +@1250 := @1199 @34 +@1251 := And.left +@1252 := And.right +@1255 := @1251 @1249 @1250 @26 +@1258 := @1252 @1249 @1250 @26 +@1259 := @1001 @26 +@1261 := fun (__e_o : @638) => @1259 @9 +@1262 := Eq.subst.{1} +@1264 := @1214 @78 @31 +@1265 := @1225 @1264 +@1269 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.entry_accepts @71 @78 @26 +@1272 := @1217 (@1218 @71 @78) +@1277 := @1251 (@1183 @9) (@1186 @9) @34 +@1279 := fun (__e_o : @638) => @1259 @31 +@1282 := @1262 @638 @1279 @1115 +@1286 := fun (__e_h : @1264) => @1282 @1272 @1269 @1277 +@1290 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.entry_refuses @71 @78 @26 +@1294 := fun (__e_h : @1265) => @1282 @1224 @1290 @1277 +@1295 := And.intro +@1298 := @1264 -> @1001 @1272 @9 +@1300 := @1265 -> @1239 @9 +@1302 := @728 @1298 @1300 +@1306 := @1295 @1298 @1300 @1286 @1294 +@1310 := @1295 @1250 @1302 @1258 @1306 +@1311 := Exists.intro.{1} +@1312 := @728 @1187 +@1314 := @1214 @71 @78 +@1326 := fun (__e_ro : @726) => + @1312 (@728 (@1314 -> @1001 (@1217 (@1218 @91 @71)) @34) (@1225 @1314 -> @1240)) +@1330 := @1311 @726 @1326 @34 @1310 +@1332 := @728 @1249 @1250 +@1334 := fun (__e_ro : @726) => fun (__e_hand : @1211) => @1330 +@1340 := Exists.elim.{1} @726 @1248 @1247 @1205 @1334 +@1341 := LexLeanPreservation.Rust.RepresentableL +@1342 := @18 @34 +@1344 := @356 @36 @355 +@1347 := @1341 (@356 @1342 @1344) +@1348 := (__e_hrep : @1347) -> @1247 +@1349 := fun (__e_hrep : @1347) => @1340 +@1350 := (bonus : @3) -> @1348 +@1351 := fun (bonus : @3) => @1349 +@1352 := (m : @8) -> @1350 +@1353 := fun (m : @8) => @1351 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustCore.lean deleted file mode 100644 index a4f3d2f83..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (n : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat n) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustCore.lex.tex new file mode 100644 index 000000000..c491d9fe9 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustCore.lex.tex @@ -0,0 +1,418 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore.root : @826 := @827 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore.flags +@3 := Nat +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@59 := Prod.{0, 0} @3 @50 +@60 := 0 +@64 := Prod.mk.{0, 0} @3 @50 @60 +@65 := @64 @6 +@66 := @51 @59 +@67 := @52 @59 +@69 := @67 @65 @66 +@70 := Bool.false +@71 := LexLeanTarget.TargetSyntax.Function +@72 := LexLeanTarget.TargetSyntax.Program.functions +@73 := @72 @0 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := @51 @3 +@76 := @51 @74 +@77 := LexLeanTarget.TargetSyntax.Ty.unit +@78 := LexLeanTarget.TargetSyntax.Value.unit +@81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 +@86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 +@91 := List.getD.{0} @71 @73 @60 @86 +@95 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore.root @17 @60 +@96 := LexLeanPreservation.Rust.WTL +@104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 +@106 := LexLeanPreservation.Rust.wtl_nil @0 +@107 := @96 @0 +@113 := {c : @9} -> {A : @10} -> @107 @4 @17 @53 @76 +@114 := @106 @1 +@115 := @107 @1 +@119 := {A : @10} -> @115 @17 @53 @76 +@120 := @114 @2 +@121 := @115 @2 +@122 := @121 @53 +@123 := @122 @76 +@124 := List.{0} +@125 := @124 @50 +@126 := @124 @74 +@127 := #6 +@128 := @11 @127 +@129 := #5 +@130 := @128 @129 +@131 := #4 +@134 := @130 @131 @12 @14 +@135 := #7 +@140 := @96 @135 @127 @129 @14 @4 +@141 := #8 +@144 := @96 @141 @135 @127 +@146 := @54 @129 @12 +@147 := @144 @146 +@148 := @52 @74 +@150 := @148 @131 @14 +@160 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @134) -> (hs : @140) -> @147 @150 +@162 := LexLeanPreservation.Rust.wtl_cons @0 +@182 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> + (h : @27 @129 @131 @12 @14) -> (hs : @107 @127 @129 @14 @4) -> @107 @135 @127 @146 @150 +@183 := @162 @1 +@199 := {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> (h : @36 @131 @12 @14) -> (hs : @115 @129 @14 @4) -> @115 @127 @146 @150 +@200 := @183 @2 +@202 := @43 @12 @14 +@204 := @121 @14 @4 +@212 := {v : @50} -> + {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @202) -> (hs : @204) -> @121 @146 @150 +@213 := @200 @6 +@214 := @5 @131 +@216 := @43 @214 @14 +@217 := @5 @127 +@218 := @54 @217 +@226 := {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @216) -> (hs : @204) -> @121 (@218 @12) @150 +@227 := @213 @7 +@228 := @5 @12 +@230 := @43 @228 @7 +@231 := @5 @129 +@232 := @54 @231 +@234 := @121 (@232 @12) +@235 := @148 @7 +@236 := @235 @14 +@241 := {vs : @125} -> {ts : @126} -> (h : @230) -> (hs : @204) -> @234 @236 +@242 := @227 @53 +@243 := @5 @14 +@245 := @43 @243 @7 +@246 := @122 @4 +@248 := @54 @214 @53 +@249 := @121 @248 +@253 := {ts : @126} -> (h : @245) -> (hs : @246) -> @249 @236 +@254 := @242 @76 +@256 := @54 @228 @53 +@257 := @121 @256 +@258 := @235 @76 +@261 := (h : @49) -> (hs : @123) -> @257 @258 +@262 := @254 @47 +@264 := @54 @243 @53 +@265 := @121 @264 +@267 := (hs : @123) -> @265 @258 +@268 := @262 @120 +@269 := @121 @56 +@270 := @269 @258 +@271 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.denote +@272 := @271 @4 +@273 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.__fits_0 +@274 := @273 @4 +@276 := Coverage.Main.parity @4 +@278 := LexLeanTarget.TargetSyntax.Value.bool @276 +@280 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.root @4 +@281 := Bool +@282 := Ne.{1} +@283 := LexLeanPreservation.Obs +@284 := @282 @283 +@285 := LexLeanPreservation.Rel +@288 := @284 (@285 @4 @17) +@289 := LexLeanPreservation.Obs.stuck +@292 := (f : @281) -> (v : @50) -> @288 @289 +@294 := LexLeanPreservation.Rust.rel_ne_stuck @274 +@300 := (v : @50) -> @284 (@285 (@273 @14) @17) @289 +@301 := @294 @278 +@305 := @284 (@285 @274 @278) @289 +@306 := @124 @59 +@307 := LexLeanPreservation.Rust.FunSem +@308 := #9 +@314 := (n : @3) -> @307 @308 @141 @135 @17 @127 +@315 := Eq.{1} +@316 := Option.{0} +@317 := @316 @71 +@318 := @315 @317 +@325 := LexLeanRuntime.index (@124 @71) @71 (LexLeanRuntime.instIndexableList @71) +@329 := @318 (@325 (@72 @308) @127) +@330 := Option.some.{0} +@331 := @330 @71 +@332 := @331 @129 +@333 := @329 @332 +@334 := #10 +@338 := @96 @334 @308 @141 @129 +@339 := LexLeanTarget.TargetSyntax.Function.types +@340 := @339 @127 +@341 := @338 @340 +@342 := @316 @306 +@343 := @315 @342 +@344 := LexLeanTarget.TargetSemantics.bindAll +@345 := LexLeanTarget.TargetSyntax.Function.parameters +@350 := @343 (@344 (@345 @135) @127 @66) +@351 := @330 @306 +@352 := @351 @129 +@353 := @350 @352 +@354 := @316 @281 +@355 := @315 @354 +@356 := LexLeanPreservation.Rust.fnFallible +@357 := #11 +@360 := @355 (@356 @357 @308) +@361 := @330 @281 +@362 := @361 @129 +@363 := @360 @362 +@364 := LexLeanPreservation.RunConv +@365 := #13 +@369 := @364 @365 @334 @141 @129 +@371 := @284 @127 @289 +@372 := Exists.{1} +@373 := LexLeanPreservation.Rust.ROut +@374 := @372 @373 +@375 := And +@376 := LexLeanPreservation.Rust.RealizesFn +@380 := @375 (@376 @308 @141 @17) +@381 := LexLeanPreservation.Rust.RCI +@383 := @381 #15 +@384 := LexLeanPreservation.Rust.fnIdent +@385 := @384 @365 +@392 := (hne : @371) -> @374 (fun (ro : @373) => @380 (@383 @385 @357 @17)) +@407 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @314) -> + (hfn : @333) -> (hwt : @341) -> (hbind : @353) -> (hF : @363) -> (hA : @369) -> @392 +@409 := LexLeanPreservation.Rust.compose @0 +@410 := @307 @0 +@415 := (n : @3) -> @410 @141 @135 @17 @127 +@416 := @325 @73 +@419 := @318 (@416 @127) @332 +@423 := @107 @308 @141 @129 @340 +@424 := @364 @0 +@427 := @424 @334 @141 @129 +@441 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @415) -> + (hfn : @419) -> (hwt : @423) -> (hbind : @353) -> (hF : @363) -> (hA : @427) -> @392 +@442 := @409 @1 +@443 := @410 @1 +@447 := (n : @3) -> @443 @135 @17 @127 +@450 := @115 @141 @129 @340 +@451 := @356 @1 +@454 := @355 (@451 @308) @362 +@455 := @381 @1 +@465 := (hbind : @353) -> + (hF : @454) -> (hA : @427) -> (hne : @371) -> @374 (fun (ro : @373) => @380 (@455 @385 @357 @17)) +@475 := {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @306} -> {F : @281} -> {o : @283} -> (hB : @447) -> (hfn : @419) -> (hwt : @450) -> @465 +@476 := @442 @2 +@478 := @443 @2 @17 +@480 := (n : @3) -> @478 @127 +@481 := @121 @129 +@482 := @481 @340 +@491 := {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @306} -> {F : @281} -> {o : @283} -> (hB : @480) -> (hfn : @419) -> (hwt : @482) -> @465 +@492 := @476 @60 +@494 := (n : @3) -> @478 @60 +@495 := @416 @60 +@496 := @318 @495 +@497 := @496 @332 +@498 := @451 @60 +@499 := @355 @498 +@500 := @499 @362 +@501 := @424 @60 +@503 := @501 @141 @129 +@505 := @455 (@384 @60) +@513 := (hF : @500) -> (hA : @503) -> (hne : @371) -> @374 (fun (ro : @373) => @380 (@505 @357 @17)) +@522 := {fn : @71} -> + {args : @125} -> + {env : @306} -> + {F : @281} -> {o : @283} -> (hB : @494) -> (hfn : @497) -> (hwt : @482) -> (hbind : @353) -> @513 +@523 := @492 @91 +@525 := @496 (@331 @91) +@526 := @339 @91 +@527 := @481 @526 +@529 := @344 (@345 @91) +@541 := {args : @125} -> + {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @494) -> (hfn : @525) -> (hwt : @527) -> (hbind : @343 (@529 @127 @66) @352) -> @513 +@542 := @523 @56 +@543 := @218 @53 +@545 := @121 @543 @526 +@548 := @54 (@5 @135) @53 +@552 := @343 (@529 @548 @66) @352 +@555 := @54 (@5 @308) @53 +@576 := {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @494) -> + (hfn : @525) -> + (hwt : @545) -> + (hbind : @552) -> + (hF : @500) -> + (hA : @501 @555 @129) -> + (hne : @371) -> @374 (fun (ro : @373) => @380 (@505 (@54 (@5 #12) @53) @17)) +@577 := @542 @69 +@578 := @232 @53 +@580 := @121 @578 @526 +@588 := @343 (@529 @543 @66) (@351 (@67 (@64 @217) @66)) +@591 := @54 (@5 @141) @53 +@610 := {F : @281} -> + {o : @283} -> + (hB : @494) -> + (hfn : @525) -> + (hwt : @580) -> + (hbind : @588) -> + (hF : @500) -> + (hA : @501 @591 @129) -> + (hne : @371) -> @374 (fun (ro : @373) => @380 (@505 (@54 (@5 @357) @53) @17)) +@611 := @577 @70 +@612 := @249 @526 +@620 := @343 (@529 @578 @66) (@351 (@67 (@64 @231) @66)) +@622 := @499 (@361 @70) +@624 := @501 @548 @129 +@625 := @376 @70 +@644 := {o : @283} -> + (hB : @494) -> + (hfn : @525) -> + (hwt : @612) -> + (hbind : @620) -> + (hF : @622) -> + (hA : @624) -> + (hne : @371) -> @374 (fun (ro : @373) => @375 (@625 @141 @17) (@505 (@54 (@5 @334) @53) @17)) +@645 := @611 @272 +@646 := @257 @526 +@654 := @343 (@529 @248 @66) (@351 (@67 (@64 @214) @66)) +@655 := @501 @543 +@656 := @271 @127 +@657 := @655 @656 +@658 := @271 @135 +@676 := (hB : @494) -> + (hfn : @525) -> + (hwt : @646) -> + (hbind : @654) -> + (hF : @622) -> + (hA : @657) -> + (hne : @284 @658 @289) -> @374 (fun (ro : @373) => @375 (@625 (@271 @308) @17) (@505 @555 @17)) +@677 := @645 @95 +@678 := @265 @526 +@686 := @343 (@529 @256 @66) (@351 (@67 (@64 @228) @66)) +@687 := @501 @578 +@688 := @271 @129 +@706 := (hfn : @525) -> + (hwt : @678) -> + (hbind : @686) -> + (hF : @622) -> + (hA : @687 @688) -> + (hne : @284 @656 @289) -> @374 (fun (ro : @373) => @375 (@625 (@271 @141) @17) (@505 @591 @17)) +@707 := Eq.refl.{1} +@710 := @677 (@707 @317 @495) +@711 := @269 @526 +@719 := @343 (@529 @264 @66) (@351 (@67 (@64 @243) @66)) +@720 := @501 @248 +@721 := @271 @131 +@737 := (hwt : @711) -> + (hbind : @719) -> + (hF : @622) -> + (hA : @720 @721) -> + (hne : @284 @688 @289) -> @374 (fun (ro : @373) => @375 (@625 @658 @17) (@505 @548 @17)) +@738 := @710 @268 +@740 := @529 @56 @66 +@743 := @343 @740 (@351 @69) +@744 := @501 @256 +@745 := @271 @12 +@760 := (hbind : @743) -> + (hF : @622) -> + (hA : @744 @745) -> + (hne : @284 @721 @289) -> @374 (fun (ro : @373) => @375 (@625 @656 @17) (@505 @543 @17)) +@763 := @738 (@707 @342 @740) +@764 := @501 @264 +@765 := @271 @14 +@779 := (hF : @622) -> + (hA : @764 @765) -> + (hne : @284 @745 @289) -> @374 (fun (ro : @373) => @375 (@625 @688 @17) (@505 @578 @17)) +@782 := @763 (@707 @354 @498) +@796 := (hA : @501 @56 @272) -> + (hne : @284 @765 @289) -> @374 (fun (ro : @373) => @375 (@625 @721 @17) (@505 @248 @17)) +@797 := @782 @280 +@808 := (hne : @284 @272 @289) -> @374 (fun (ro : @373) => @375 (@625 @745 @17) (@505 @256 @17)) +@809 := @797 @301 +@815 := @375 (@625 @765 @17) (@505 @264 @17) +@817 := @374 (fun (ro : @373) => @815) +@819 := @374 (fun (__e_ro : @373) => @815) +@823 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@824 := (__e_hrep : @823) -> @819 +@825 := fun (__e_hrep : @823) => @809 +@826 := (n : @3) -> @824 +@827 := fun (n : @3) => @825 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustStd.lean deleted file mode 100644 index b10b82cce..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (n : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat n) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustStd.lex.tex new file mode 100644 index 000000000..c512e6584 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustStd.lex.tex @@ -0,0 +1,418 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd.root : @826 := @827 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd.flags +@3 := Nat +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@59 := Prod.{0, 0} @3 @50 +@60 := 0 +@64 := Prod.mk.{0, 0} @3 @50 @60 +@65 := @64 @6 +@66 := @51 @59 +@67 := @52 @59 +@69 := @67 @65 @66 +@70 := Bool.false +@71 := LexLeanTarget.TargetSyntax.Function +@72 := LexLeanTarget.TargetSyntax.Program.functions +@73 := @72 @0 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := @51 @3 +@76 := @51 @74 +@77 := LexLeanTarget.TargetSyntax.Ty.unit +@78 := LexLeanTarget.TargetSyntax.Value.unit +@81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 +@86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 +@91 := List.getD.{0} @71 @73 @60 @86 +@95 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd.root @17 @60 +@96 := LexLeanPreservation.Rust.WTL +@104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 +@106 := LexLeanPreservation.Rust.wtl_nil @0 +@107 := @96 @0 +@113 := {c : @9} -> {A : @10} -> @107 @4 @17 @53 @76 +@114 := @106 @1 +@115 := @107 @1 +@119 := {A : @10} -> @115 @17 @53 @76 +@120 := @114 @2 +@121 := @115 @2 +@122 := @121 @53 +@123 := @122 @76 +@124 := List.{0} +@125 := @124 @50 +@126 := @124 @74 +@127 := #6 +@128 := @11 @127 +@129 := #5 +@130 := @128 @129 +@131 := #4 +@134 := @130 @131 @12 @14 +@135 := #7 +@140 := @96 @135 @127 @129 @14 @4 +@141 := #8 +@144 := @96 @141 @135 @127 +@146 := @54 @129 @12 +@147 := @144 @146 +@148 := @52 @74 +@150 := @148 @131 @14 +@160 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @134) -> (hs : @140) -> @147 @150 +@162 := LexLeanPreservation.Rust.wtl_cons @0 +@182 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> + (h : @27 @129 @131 @12 @14) -> (hs : @107 @127 @129 @14 @4) -> @107 @135 @127 @146 @150 +@183 := @162 @1 +@199 := {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> (h : @36 @131 @12 @14) -> (hs : @115 @129 @14 @4) -> @115 @127 @146 @150 +@200 := @183 @2 +@202 := @43 @12 @14 +@204 := @121 @14 @4 +@212 := {v : @50} -> + {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @202) -> (hs : @204) -> @121 @146 @150 +@213 := @200 @6 +@214 := @5 @131 +@216 := @43 @214 @14 +@217 := @5 @127 +@218 := @54 @217 +@226 := {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @216) -> (hs : @204) -> @121 (@218 @12) @150 +@227 := @213 @7 +@228 := @5 @12 +@230 := @43 @228 @7 +@231 := @5 @129 +@232 := @54 @231 +@234 := @121 (@232 @12) +@235 := @148 @7 +@236 := @235 @14 +@241 := {vs : @125} -> {ts : @126} -> (h : @230) -> (hs : @204) -> @234 @236 +@242 := @227 @53 +@243 := @5 @14 +@245 := @43 @243 @7 +@246 := @122 @4 +@248 := @54 @214 @53 +@249 := @121 @248 +@253 := {ts : @126} -> (h : @245) -> (hs : @246) -> @249 @236 +@254 := @242 @76 +@256 := @54 @228 @53 +@257 := @121 @256 +@258 := @235 @76 +@261 := (h : @49) -> (hs : @123) -> @257 @258 +@262 := @254 @47 +@264 := @54 @243 @53 +@265 := @121 @264 +@267 := (hs : @123) -> @265 @258 +@268 := @262 @120 +@269 := @121 @56 +@270 := @269 @258 +@271 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.denote +@272 := @271 @4 +@273 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.__fits_0 +@274 := @273 @4 +@276 := Coverage.Main.parity @4 +@278 := LexLeanTarget.TargetSyntax.Value.bool @276 +@280 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.root @4 +@281 := Bool +@282 := Ne.{1} +@283 := LexLeanPreservation.Obs +@284 := @282 @283 +@285 := LexLeanPreservation.Rel +@288 := @284 (@285 @4 @17) +@289 := LexLeanPreservation.Obs.stuck +@292 := (f : @281) -> (v : @50) -> @288 @289 +@294 := LexLeanPreservation.Rust.rel_ne_stuck @274 +@300 := (v : @50) -> @284 (@285 (@273 @14) @17) @289 +@301 := @294 @278 +@305 := @284 (@285 @274 @278) @289 +@306 := @124 @59 +@307 := LexLeanPreservation.Rust.FunSem +@308 := #9 +@314 := (n : @3) -> @307 @308 @141 @135 @17 @127 +@315 := Eq.{1} +@316 := Option.{0} +@317 := @316 @71 +@318 := @315 @317 +@325 := LexLeanRuntime.index (@124 @71) @71 (LexLeanRuntime.instIndexableList @71) +@329 := @318 (@325 (@72 @308) @127) +@330 := Option.some.{0} +@331 := @330 @71 +@332 := @331 @129 +@333 := @329 @332 +@334 := #10 +@338 := @96 @334 @308 @141 @129 +@339 := LexLeanTarget.TargetSyntax.Function.types +@340 := @339 @127 +@341 := @338 @340 +@342 := @316 @306 +@343 := @315 @342 +@344 := LexLeanTarget.TargetSemantics.bindAll +@345 := LexLeanTarget.TargetSyntax.Function.parameters +@350 := @343 (@344 (@345 @135) @127 @66) +@351 := @330 @306 +@352 := @351 @129 +@353 := @350 @352 +@354 := @316 @281 +@355 := @315 @354 +@356 := LexLeanPreservation.Rust.fnFallible +@357 := #11 +@360 := @355 (@356 @357 @308) +@361 := @330 @281 +@362 := @361 @129 +@363 := @360 @362 +@364 := LexLeanPreservation.RunConv +@365 := #13 +@369 := @364 @365 @334 @141 @129 +@371 := @284 @127 @289 +@372 := Exists.{1} +@373 := LexLeanPreservation.Rust.ROut +@374 := @372 @373 +@375 := And +@376 := LexLeanPreservation.Rust.RealizesFn +@380 := @375 (@376 @308 @141 @17) +@381 := LexLeanPreservation.Rust.RCI +@383 := @381 #15 +@384 := LexLeanPreservation.Rust.fnIdent +@385 := @384 @365 +@392 := (hne : @371) -> @374 (fun (ro : @373) => @380 (@383 @385 @357 @17)) +@407 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @314) -> + (hfn : @333) -> (hwt : @341) -> (hbind : @353) -> (hF : @363) -> (hA : @369) -> @392 +@409 := LexLeanPreservation.Rust.compose @0 +@410 := @307 @0 +@415 := (n : @3) -> @410 @141 @135 @17 @127 +@416 := @325 @73 +@419 := @318 (@416 @127) @332 +@423 := @107 @308 @141 @129 @340 +@424 := @364 @0 +@427 := @424 @334 @141 @129 +@441 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @415) -> + (hfn : @419) -> (hwt : @423) -> (hbind : @353) -> (hF : @363) -> (hA : @427) -> @392 +@442 := @409 @1 +@443 := @410 @1 +@447 := (n : @3) -> @443 @135 @17 @127 +@450 := @115 @141 @129 @340 +@451 := @356 @1 +@454 := @355 (@451 @308) @362 +@455 := @381 @1 +@465 := (hbind : @353) -> + (hF : @454) -> (hA : @427) -> (hne : @371) -> @374 (fun (ro : @373) => @380 (@455 @385 @357 @17)) +@475 := {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @306} -> {F : @281} -> {o : @283} -> (hB : @447) -> (hfn : @419) -> (hwt : @450) -> @465 +@476 := @442 @2 +@478 := @443 @2 @17 +@480 := (n : @3) -> @478 @127 +@481 := @121 @129 +@482 := @481 @340 +@491 := {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @306} -> {F : @281} -> {o : @283} -> (hB : @480) -> (hfn : @419) -> (hwt : @482) -> @465 +@492 := @476 @60 +@494 := (n : @3) -> @478 @60 +@495 := @416 @60 +@496 := @318 @495 +@497 := @496 @332 +@498 := @451 @60 +@499 := @355 @498 +@500 := @499 @362 +@501 := @424 @60 +@503 := @501 @141 @129 +@505 := @455 (@384 @60) +@513 := (hF : @500) -> (hA : @503) -> (hne : @371) -> @374 (fun (ro : @373) => @380 (@505 @357 @17)) +@522 := {fn : @71} -> + {args : @125} -> + {env : @306} -> + {F : @281} -> {o : @283} -> (hB : @494) -> (hfn : @497) -> (hwt : @482) -> (hbind : @353) -> @513 +@523 := @492 @91 +@525 := @496 (@331 @91) +@526 := @339 @91 +@527 := @481 @526 +@529 := @344 (@345 @91) +@541 := {args : @125} -> + {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @494) -> (hfn : @525) -> (hwt : @527) -> (hbind : @343 (@529 @127 @66) @352) -> @513 +@542 := @523 @56 +@543 := @218 @53 +@545 := @121 @543 @526 +@548 := @54 (@5 @135) @53 +@552 := @343 (@529 @548 @66) @352 +@555 := @54 (@5 @308) @53 +@576 := {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @494) -> + (hfn : @525) -> + (hwt : @545) -> + (hbind : @552) -> + (hF : @500) -> + (hA : @501 @555 @129) -> + (hne : @371) -> @374 (fun (ro : @373) => @380 (@505 (@54 (@5 #12) @53) @17)) +@577 := @542 @69 +@578 := @232 @53 +@580 := @121 @578 @526 +@588 := @343 (@529 @543 @66) (@351 (@67 (@64 @217) @66)) +@591 := @54 (@5 @141) @53 +@610 := {F : @281} -> + {o : @283} -> + (hB : @494) -> + (hfn : @525) -> + (hwt : @580) -> + (hbind : @588) -> + (hF : @500) -> + (hA : @501 @591 @129) -> + (hne : @371) -> @374 (fun (ro : @373) => @380 (@505 (@54 (@5 @357) @53) @17)) +@611 := @577 @70 +@612 := @249 @526 +@620 := @343 (@529 @578 @66) (@351 (@67 (@64 @231) @66)) +@622 := @499 (@361 @70) +@624 := @501 @548 @129 +@625 := @376 @70 +@644 := {o : @283} -> + (hB : @494) -> + (hfn : @525) -> + (hwt : @612) -> + (hbind : @620) -> + (hF : @622) -> + (hA : @624) -> + (hne : @371) -> @374 (fun (ro : @373) => @375 (@625 @141 @17) (@505 (@54 (@5 @334) @53) @17)) +@645 := @611 @272 +@646 := @257 @526 +@654 := @343 (@529 @248 @66) (@351 (@67 (@64 @214) @66)) +@655 := @501 @543 +@656 := @271 @127 +@657 := @655 @656 +@658 := @271 @135 +@676 := (hB : @494) -> + (hfn : @525) -> + (hwt : @646) -> + (hbind : @654) -> + (hF : @622) -> + (hA : @657) -> + (hne : @284 @658 @289) -> @374 (fun (ro : @373) => @375 (@625 (@271 @308) @17) (@505 @555 @17)) +@677 := @645 @95 +@678 := @265 @526 +@686 := @343 (@529 @256 @66) (@351 (@67 (@64 @228) @66)) +@687 := @501 @578 +@688 := @271 @129 +@706 := (hfn : @525) -> + (hwt : @678) -> + (hbind : @686) -> + (hF : @622) -> + (hA : @687 @688) -> + (hne : @284 @656 @289) -> @374 (fun (ro : @373) => @375 (@625 (@271 @141) @17) (@505 @591 @17)) +@707 := Eq.refl.{1} +@710 := @677 (@707 @317 @495) +@711 := @269 @526 +@719 := @343 (@529 @264 @66) (@351 (@67 (@64 @243) @66)) +@720 := @501 @248 +@721 := @271 @131 +@737 := (hwt : @711) -> + (hbind : @719) -> + (hF : @622) -> + (hA : @720 @721) -> + (hne : @284 @688 @289) -> @374 (fun (ro : @373) => @375 (@625 @658 @17) (@505 @548 @17)) +@738 := @710 @268 +@740 := @529 @56 @66 +@743 := @343 @740 (@351 @69) +@744 := @501 @256 +@745 := @271 @12 +@760 := (hbind : @743) -> + (hF : @622) -> + (hA : @744 @745) -> + (hne : @284 @721 @289) -> @374 (fun (ro : @373) => @375 (@625 @656 @17) (@505 @543 @17)) +@763 := @738 (@707 @342 @740) +@764 := @501 @264 +@765 := @271 @14 +@779 := (hF : @622) -> + (hA : @764 @765) -> + (hne : @284 @745 @289) -> @374 (fun (ro : @373) => @375 (@625 @688 @17) (@505 @578 @17)) +@782 := @763 (@707 @354 @498) +@796 := (hA : @501 @56 @272) -> + (hne : @284 @765 @289) -> @374 (fun (ro : @373) => @375 (@625 @721 @17) (@505 @248 @17)) +@797 := @782 @280 +@808 := (hne : @284 @272 @289) -> @374 (fun (ro : @373) => @375 (@625 @745 @17) (@505 @256 @17)) +@809 := @797 @301 +@815 := @375 (@625 @765 @17) (@505 @264 @17) +@817 := @374 (fun (ro : @373) => @815) +@819 := @374 (fun (__e_ro : @373) => @815) +@823 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@824 := (__e_hrep : @823) -> @819 +@825 := fun (__e_hrep : @823) => @809 +@826 := (n : @3) -> @824 +@827 := fun (n : @3) => @825 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustCore.lean deleted file mode 100644 index 343367cfe..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int8) (b : Int8) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.i8 a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.i8 a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i8 a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i8 b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustCore.lex.tex new file mode 100644 index 000000000..2a5dd53c2 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustCore.lex.tex @@ -0,0 +1,475 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore.root : @939 := @940 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore.flags +@3 := Int8 +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.i8 +@6 := @5 @4 +@9 := LexLeanTarget.TargetSyntax.Ty.fixed LexLeanTarget.TargetSyntax.IntKind.i8 +@10 := LexLeanTarget.TargetSyntax.Program +@11 := LexLeanPreservation.Rust.RCrate +@12 := LexLeanPreservation.Rust.Flags +@13 := LexLeanPreservation.Rust.WT +@14 := #3 +@16 := @13 @14 @4 +@17 := #1 +@18 := @16 @17 +@19 := #0 +@20 := @5 @19 +@26 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @3) -> @18 @20 @9 +@28 := LexLeanPreservation.Rust.wt_i8 @0 +@29 := @13 @0 +@36 := {c : @11} -> {A : @12} -> (x : @3) -> @29 @4 @17 @20 @9 +@37 := @28 @1 +@38 := @29 @1 +@43 := {A : @12} -> (x : @3) -> @38 @17 @20 @9 +@44 := @37 @2 +@45 := @38 @2 +@48 := (x : @3) -> @45 @20 @9 +@49 := @44 @4 +@51 := @45 @6 @9 +@52 := @5 @17 +@53 := @44 @17 +@55 := @45 @52 @9 +@56 := LexLeanTarget.TargetSyntax.Value +@57 := List.nil.{0} +@58 := List.cons.{0} +@59 := @57 @56 +@60 := @58 @56 +@61 := @60 @52 +@62 := @61 @59 +@63 := @60 @6 +@64 := @63 @62 +@65 := Nat +@66 := Prod.{0, 0} +@68 := @66 @65 @56 +@69 := 1 +@72 := Prod.mk.{0, 0} @65 @56 +@73 := @72 @69 +@74 := @73 @52 +@75 := 0 +@76 := @72 @75 +@77 := @76 @6 +@78 := @57 @68 +@79 := @58 @68 +@81 := @79 @77 @78 +@83 := @79 @74 @81 +@84 := Bool.false +@85 := LexLeanTarget.TargetSyntax.Function +@86 := LexLeanTarget.TargetSyntax.Program.functions +@87 := @86 @0 +@88 := LexLeanTarget.TargetSyntax.Ty +@89 := @57 @65 +@90 := @57 @88 +@91 := LexLeanTarget.TargetSyntax.Ty.unit +@92 := LexLeanTarget.TargetSyntax.Value.unit +@95 := LexLeanTarget.TargetSyntax.Expr.value @91 @92 +@100 := LexLeanTarget.TargetSyntax.Function.mk @89 @90 @91 @95 +@105 := List.getD.{0} @85 @87 @75 @100 +@109 := fun (__e_n : @65) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore.root @19 @75 +@110 := LexLeanPreservation.Rust.WTL +@118 := {p : @10} -> {c : @11} -> {A : @12} -> @110 @4 @17 @19 @59 @90 +@120 := LexLeanPreservation.Rust.wtl_nil @0 +@121 := @110 @0 +@127 := {c : @11} -> {A : @12} -> @121 @17 @19 @59 @90 +@128 := @120 @1 +@129 := @121 @1 +@133 := {A : @12} -> @129 @19 @59 @90 +@134 := @128 @2 +@135 := @129 @2 +@136 := @135 @59 +@137 := @136 @90 +@138 := List.{0} +@139 := @138 @56 +@140 := @138 @88 +@141 := #6 +@142 := @13 @141 +@143 := #5 +@144 := @142 @143 +@145 := #4 +@148 := @144 @145 @14 @4 +@149 := #7 +@154 := @110 @149 @141 @143 @4 @17 +@155 := #8 +@158 := @110 @155 @149 @141 +@160 := @60 @143 @14 +@161 := @158 @160 +@162 := @58 @88 +@164 := @162 @145 @4 +@174 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {v : @56} -> {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @148) -> (hs : @154) -> @161 @164 +@176 := LexLeanPreservation.Rust.wtl_cons @0 +@196 := {c : @11} -> + {A : @12} -> + {v : @56} -> + {t : @88} -> + {vs : @139} -> + {ts : @140} -> + (h : @29 @143 @145 @14 @4) -> (hs : @121 @141 @143 @4 @17) -> @121 @149 @141 @160 @164 +@197 := @176 @1 +@213 := {A : @12} -> + {v : @56} -> + {t : @88} -> + {vs : @139} -> + {ts : @140} -> (h : @38 @145 @14 @4) -> (hs : @129 @143 @4 @17) -> @129 @141 @160 @164 +@214 := @197 @2 +@216 := @45 @14 @4 +@218 := @135 @4 @17 +@226 := {v : @56} -> + {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @216) -> (hs : @218) -> @135 @160 @164 +@227 := @214 @52 +@228 := @5 @145 +@229 := @45 @228 +@230 := @229 @4 +@231 := @5 @141 +@232 := @60 @231 +@234 := @135 (@232 @14) +@240 := {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @230) -> (hs : @218) -> @234 @164 +@241 := @227 @9 +@242 := @5 @14 +@244 := @45 @242 @9 +@245 := @5 @143 +@246 := @60 @245 +@248 := @135 (@246 @14) +@249 := @162 @9 +@250 := @249 @4 +@255 := {vs : @139} -> {ts : @140} -> (h : @244) -> (hs : @218) -> @248 @250 +@256 := @241 @59 +@257 := @136 @17 +@258 := @60 @228 +@259 := @258 @59 +@264 := {ts : @140} -> (h : @51) -> (hs : @257) -> @135 @259 @250 +@265 := @256 @90 +@266 := @60 @242 +@267 := @266 @59 +@268 := @135 @267 +@269 := @249 @90 +@272 := (h : @55) -> (hs : @137) -> @268 @269 +@273 := @265 @53 +@274 := @63 @59 +@276 := @135 @274 @269 +@277 := (hs : @137) -> @276 +@278 := @273 @134 +@280 := @135 @62 @269 +@281 := @214 @6 +@283 := @45 @245 @4 +@284 := @5 @149 +@285 := @60 @284 +@293 := {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @283) -> (hs : @218) -> @135 (@285 @14) @164 +@294 := @281 @9 +@300 := {vs : @139} -> {ts : @140} -> (h : @229 @9) -> (hs : @218) -> @234 @250 +@301 := @294 @62 +@302 := @268 @17 +@303 := @246 @259 +@304 := @135 @303 +@308 := {ts : @140} -> (h : @244) -> (hs : @302) -> @304 @250 +@309 := @301 @269 +@310 := @258 @267 +@311 := @135 @310 +@312 := @249 @269 +@315 := (h : @51) -> (hs : @276) -> @311 @312 +@316 := @309 @49 +@317 := @266 @274 +@318 := @135 @317 +@320 := (hs : @280) -> @318 @312 +@321 := @316 @278 +@322 := @135 @64 +@323 := @322 @312 +@324 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.denote +@326 := @324 @4 @17 +@327 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.__fits_0 +@329 := @327 @4 @17 +@332 := Coverage.Prims.fixedSmall @4 @17 +@333 := Option.{0} +@334 := @333 @3 +@335 := @66 @334 +@336 := @335 @334 +@337 := @335 @336 +@338 := @335 @337 +@341 := LexLeanPreservation.encOption @3 @5 +@343 := LexLeanPreservation.encPair @334 +@346 := @343 @334 @341 @341 +@349 := @343 @336 @341 @346 +@352 := @343 @337 @341 @349 +@356 := @343 @338 @341 @352 @332 +@359 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.root @4 @17 +@360 := Bool +@361 := Ne.{1} +@362 := LexLeanPreservation.Obs +@363 := @361 @362 +@364 := LexLeanPreservation.Rel +@367 := @363 (@364 @17 @19) +@368 := LexLeanPreservation.Obs.stuck +@371 := (f : @360) -> (v : @56) -> @367 @368 +@373 := LexLeanPreservation.Rust.rel_ne_stuck @329 +@380 := (v : @56) -> @363 (@364 (@327 @14 @4) @19) @368 +@381 := @373 @356 +@385 := @363 (@364 @329 @356) @368 +@386 := @138 @68 +@387 := LexLeanPreservation.Rust.FunSem +@388 := #9 +@394 := (n : @65) -> @387 @388 @155 @149 @19 @141 +@395 := Eq.{1} +@396 := @333 @85 +@397 := @395 @396 +@404 := LexLeanRuntime.index (@138 @85) @85 (LexLeanRuntime.instIndexableList @85) +@408 := @397 (@404 (@86 @388) @141) +@409 := Option.some.{0} +@410 := @409 @85 +@411 := @410 @143 +@412 := @408 @411 +@413 := #10 +@417 := @110 @413 @388 @155 @143 +@418 := LexLeanTarget.TargetSyntax.Function.types +@419 := @418 @141 +@420 := @417 @419 +@421 := @333 @386 +@422 := @395 @421 +@423 := LexLeanTarget.TargetSemantics.bindAll +@424 := LexLeanTarget.TargetSyntax.Function.parameters +@429 := @422 (@423 (@424 @149) @141 @78) +@430 := @409 @386 +@431 := @430 @143 +@432 := @429 @431 +@433 := @333 @360 +@434 := @395 @433 +@435 := LexLeanPreservation.Rust.fnFallible +@436 := #11 +@439 := @434 (@435 @436 @388) +@440 := @409 @360 +@441 := @440 @143 +@442 := @439 @441 +@443 := LexLeanPreservation.RunConv +@444 := #13 +@448 := @443 @444 @413 @155 @143 +@450 := @363 @141 @368 +@451 := Exists.{1} +@452 := LexLeanPreservation.Rust.ROut +@453 := @451 @452 +@454 := And +@455 := LexLeanPreservation.Rust.RealizesFn +@459 := @454 (@455 @388 @155 @19) +@460 := LexLeanPreservation.Rust.RCI +@462 := @460 #15 +@463 := LexLeanPreservation.Rust.fnIdent +@464 := @463 @444 +@471 := (hne : @450) -> @453 (fun (ro : @452) => @459 (@462 @464 @436 @19)) +@486 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @386} -> + {F : @360} -> + {o : @362} -> + (hB : @394) -> + (hfn : @412) -> (hwt : @420) -> (hbind : @432) -> (hF : @442) -> (hA : @448) -> @471 +@488 := LexLeanPreservation.Rust.compose @0 +@489 := @387 @0 +@494 := (n : @65) -> @489 @155 @149 @19 @141 +@495 := @404 @87 +@498 := @397 (@495 @141) @411 +@502 := @121 @388 @155 @143 @419 +@503 := @443 @0 +@506 := @503 @413 @155 @143 +@520 := {c : @11} -> + {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @386} -> + {F : @360} -> + {o : @362} -> + (hB : @494) -> + (hfn : @498) -> (hwt : @502) -> (hbind : @432) -> (hF : @442) -> (hA : @506) -> @471 +@521 := @488 @1 +@522 := @489 @1 +@526 := (n : @65) -> @522 @149 @19 @141 +@529 := @129 @155 @143 @419 +@530 := @435 @1 +@533 := @434 (@530 @388) @441 +@534 := @460 @1 +@544 := (hbind : @432) -> + (hF : @533) -> (hA : @506) -> (hne : @450) -> @453 (fun (ro : @452) => @459 (@534 @464 @436 @19)) +@554 := {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @386} -> {F : @360} -> {o : @362} -> (hB : @526) -> (hfn : @498) -> (hwt : @529) -> @544 +@555 := @521 @2 +@557 := @522 @2 @19 +@559 := (n : @65) -> @557 @141 +@560 := @135 @143 +@561 := @560 @419 +@570 := {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @386} -> {F : @360} -> {o : @362} -> (hB : @559) -> (hfn : @498) -> (hwt : @561) -> @544 +@571 := @555 @75 +@573 := (n : @65) -> @557 @75 +@574 := @495 @75 +@575 := @397 @574 +@576 := @575 @411 +@577 := @530 @75 +@578 := @434 @577 +@579 := @578 @441 +@580 := @503 @75 +@582 := @580 @155 @143 +@584 := @534 (@463 @75) +@592 := (hF : @579) -> (hA : @582) -> (hne : @450) -> @453 (fun (ro : @452) => @459 (@584 @436 @19)) +@601 := {fn : @85} -> + {args : @139} -> + {env : @386} -> + {F : @360} -> {o : @362} -> (hB : @573) -> (hfn : @576) -> (hwt : @561) -> (hbind : @432) -> @592 +@602 := @571 @105 +@604 := @575 (@410 @105) +@605 := @418 @105 +@606 := @560 @605 +@608 := @423 (@424 @105) +@620 := {args : @139} -> + {env : @386} -> + {F : @360} -> + {o : @362} -> + (hB : @573) -> (hfn : @604) -> (hwt : @606) -> (hbind : @422 (@608 @141 @78) @431) -> @592 +@621 := @602 @64 +@623 := @285 (@232 @59) +@625 := @135 @623 @605 +@627 := @60 (@5 @155) +@629 := @627 (@285 @59) +@633 := @422 (@608 @629 @78) @431 +@635 := @60 (@5 @413) +@637 := @60 (@5 @388) +@639 := @635 (@637 @59) +@641 := @580 @639 @143 +@643 := @60 (@5 @444) +@646 := @60 (@5 #12) +@663 := {env : @386} -> + {F : @360} -> + {o : @362} -> + (hB : @573) -> + (hfn : @604) -> + (hwt : @625) -> + (hbind : @633) -> + (hF : @579) -> + (hA : @641) -> (hne : @450) -> @453 (fun (ro : @452) => @459 (@584 (@643 (@646 @59)) @19)) +@664 := @621 @83 +@666 := @232 (@246 @59) +@668 := @135 @666 @605 +@679 := @422 (@608 @623 @78) (@430 (@79 (@73 @231) (@79 (@76 @284) @78))) +@681 := @637 (@627 @59) +@683 := @580 @681 @143 +@685 := @60 (@5 @436) +@701 := {F : @360} -> + {o : @362} -> + (hB : @573) -> + (hfn : @604) -> + (hwt : @668) -> + (hbind : @679) -> + (hF : @579) -> + (hA : @683) -> (hne : @450) -> @453 (fun (ro : @452) => @459 (@584 (@646 (@685 @59)) @19)) +@702 := @664 @84 +@703 := @304 @605 +@714 := @422 (@608 @666 @78) (@430 (@79 (@73 @245) (@79 (@76 @231) @78))) +@716 := @578 (@440 @84) +@718 := @580 @629 @143 +@719 := @455 @84 +@737 := {o : @362} -> + (hB : @573) -> + (hfn : @604) -> + (hwt : @703) -> + (hbind : @714) -> + (hF : @716) -> + (hA : @718) -> + (hne : @450) -> @453 (fun (ro : @452) => @454 (@719 @155 @19) (@584 (@685 (@635 @59)) @19)) +@738 := @702 @326 +@739 := @311 @605 +@750 := @422 (@608 @303 @78) (@430 (@79 (@73 @228) (@79 (@76 @245) @78))) +@751 := @580 @623 +@753 := @324 @149 @141 +@754 := @751 @753 +@756 := @324 @155 @149 +@775 := (hB : @573) -> + (hfn : @604) -> + (hwt : @739) -> + (hbind : @750) -> + (hF : @716) -> + (hA : @754) -> + (hne : @363 @756 @368) -> + @453 (fun (ro : @452) => @454 (@719 (@324 @413 @388) @19) (@584 @639 @19)) +@776 := @738 @109 +@777 := @318 @605 +@788 := @422 (@608 @310 @78) (@430 (@79 (@73 @242) (@79 (@76 @228) @78))) +@789 := @580 @666 +@791 := @324 @141 @143 +@810 := (hfn : @604) -> + (hwt : @777) -> + (hbind : @788) -> + (hF : @716) -> + (hA : @789 @791) -> + (hne : @363 @753 @368) -> + @453 (fun (ro : @452) => @454 (@719 (@324 @388 @155) @19) (@584 @681 @19)) +@811 := Eq.refl.{1} +@814 := @776 (@811 @396 @574) +@815 := @322 @605 +@826 := @422 (@608 @317 @78) (@430 (@79 (@73 @6) (@79 (@76 @242) @78))) +@827 := @580 @303 +@829 := @324 @143 @145 +@845 := (hwt : @815) -> + (hbind : @826) -> + (hF : @716) -> + (hA : @827 @829) -> + (hne : @363 @791 @368) -> @453 (fun (ro : @452) => @454 (@719 @756 @19) (@584 @629 @19)) +@846 := @814 @321 +@848 := @608 @64 @78 +@851 := @422 @848 (@430 @83) +@852 := @580 @310 +@854 := @324 @145 @14 +@869 := (hbind : @851) -> + (hF : @716) -> + (hA : @852 @854) -> + (hne : @363 @829 @368) -> @453 (fun (ro : @452) => @454 (@719 @753 @19) (@584 @623 @19)) +@872 := @846 (@811 @421 @848) +@873 := @580 @317 +@875 := @324 @14 @4 +@889 := (hF : @716) -> + (hA : @873 @875) -> + (hne : @363 @854 @368) -> @453 (fun (ro : @452) => @454 (@719 @791 @19) (@584 @666 @19)) +@892 := @872 (@811 @433 @577) +@906 := (hA : @580 @64 @326) -> + (hne : @363 @875 @368) -> @453 (fun (ro : @452) => @454 (@719 @829 @19) (@584 @303 @19)) +@907 := @892 @359 +@918 := (hne : @363 @326 @368) -> @453 (fun (ro : @452) => @454 (@719 @854 @19) (@584 @310 @19)) +@919 := @907 @381 +@925 := @454 (@719 @875 @19) (@584 @317 @19) +@927 := @453 (fun (ro : @452) => @925) +@929 := @453 (fun (__e_ro : @452) => @925) +@934 := LexLeanPreservation.Rust.RepresentableL (@61 (@60 @20 @59)) +@935 := (__e_hrep : @934) -> @929 +@936 := fun (__e_hrep : @934) => @919 +@937 := (b : @3) -> @935 +@938 := fun (b : @3) => @936 +@939 := (a : @3) -> @937 +@940 := fun (a : @3) => @938 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustStd.lean deleted file mode 100644 index f0fbaf8ff..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int8) (b : Int8) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.i8 a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.i8 a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i8 a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i8 b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustStd.lex.tex new file mode 100644 index 000000000..e14b5f5ea --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustStd.lex.tex @@ -0,0 +1,475 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd.root : @939 := @940 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd.flags +@3 := Int8 +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.i8 +@6 := @5 @4 +@9 := LexLeanTarget.TargetSyntax.Ty.fixed LexLeanTarget.TargetSyntax.IntKind.i8 +@10 := LexLeanTarget.TargetSyntax.Program +@11 := LexLeanPreservation.Rust.RCrate +@12 := LexLeanPreservation.Rust.Flags +@13 := LexLeanPreservation.Rust.WT +@14 := #3 +@16 := @13 @14 @4 +@17 := #1 +@18 := @16 @17 +@19 := #0 +@20 := @5 @19 +@26 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @3) -> @18 @20 @9 +@28 := LexLeanPreservation.Rust.wt_i8 @0 +@29 := @13 @0 +@36 := {c : @11} -> {A : @12} -> (x : @3) -> @29 @4 @17 @20 @9 +@37 := @28 @1 +@38 := @29 @1 +@43 := {A : @12} -> (x : @3) -> @38 @17 @20 @9 +@44 := @37 @2 +@45 := @38 @2 +@48 := (x : @3) -> @45 @20 @9 +@49 := @44 @4 +@51 := @45 @6 @9 +@52 := @5 @17 +@53 := @44 @17 +@55 := @45 @52 @9 +@56 := LexLeanTarget.TargetSyntax.Value +@57 := List.nil.{0} +@58 := List.cons.{0} +@59 := @57 @56 +@60 := @58 @56 +@61 := @60 @52 +@62 := @61 @59 +@63 := @60 @6 +@64 := @63 @62 +@65 := Nat +@66 := Prod.{0, 0} +@68 := @66 @65 @56 +@69 := 1 +@72 := Prod.mk.{0, 0} @65 @56 +@73 := @72 @69 +@74 := @73 @52 +@75 := 0 +@76 := @72 @75 +@77 := @76 @6 +@78 := @57 @68 +@79 := @58 @68 +@81 := @79 @77 @78 +@83 := @79 @74 @81 +@84 := Bool.false +@85 := LexLeanTarget.TargetSyntax.Function +@86 := LexLeanTarget.TargetSyntax.Program.functions +@87 := @86 @0 +@88 := LexLeanTarget.TargetSyntax.Ty +@89 := @57 @65 +@90 := @57 @88 +@91 := LexLeanTarget.TargetSyntax.Ty.unit +@92 := LexLeanTarget.TargetSyntax.Value.unit +@95 := LexLeanTarget.TargetSyntax.Expr.value @91 @92 +@100 := LexLeanTarget.TargetSyntax.Function.mk @89 @90 @91 @95 +@105 := List.getD.{0} @85 @87 @75 @100 +@109 := fun (__e_n : @65) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd.root @19 @75 +@110 := LexLeanPreservation.Rust.WTL +@118 := {p : @10} -> {c : @11} -> {A : @12} -> @110 @4 @17 @19 @59 @90 +@120 := LexLeanPreservation.Rust.wtl_nil @0 +@121 := @110 @0 +@127 := {c : @11} -> {A : @12} -> @121 @17 @19 @59 @90 +@128 := @120 @1 +@129 := @121 @1 +@133 := {A : @12} -> @129 @19 @59 @90 +@134 := @128 @2 +@135 := @129 @2 +@136 := @135 @59 +@137 := @136 @90 +@138 := List.{0} +@139 := @138 @56 +@140 := @138 @88 +@141 := #6 +@142 := @13 @141 +@143 := #5 +@144 := @142 @143 +@145 := #4 +@148 := @144 @145 @14 @4 +@149 := #7 +@154 := @110 @149 @141 @143 @4 @17 +@155 := #8 +@158 := @110 @155 @149 @141 +@160 := @60 @143 @14 +@161 := @158 @160 +@162 := @58 @88 +@164 := @162 @145 @4 +@174 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {v : @56} -> {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @148) -> (hs : @154) -> @161 @164 +@176 := LexLeanPreservation.Rust.wtl_cons @0 +@196 := {c : @11} -> + {A : @12} -> + {v : @56} -> + {t : @88} -> + {vs : @139} -> + {ts : @140} -> + (h : @29 @143 @145 @14 @4) -> (hs : @121 @141 @143 @4 @17) -> @121 @149 @141 @160 @164 +@197 := @176 @1 +@213 := {A : @12} -> + {v : @56} -> + {t : @88} -> + {vs : @139} -> + {ts : @140} -> (h : @38 @145 @14 @4) -> (hs : @129 @143 @4 @17) -> @129 @141 @160 @164 +@214 := @197 @2 +@216 := @45 @14 @4 +@218 := @135 @4 @17 +@226 := {v : @56} -> + {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @216) -> (hs : @218) -> @135 @160 @164 +@227 := @214 @52 +@228 := @5 @145 +@229 := @45 @228 +@230 := @229 @4 +@231 := @5 @141 +@232 := @60 @231 +@234 := @135 (@232 @14) +@240 := {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @230) -> (hs : @218) -> @234 @164 +@241 := @227 @9 +@242 := @5 @14 +@244 := @45 @242 @9 +@245 := @5 @143 +@246 := @60 @245 +@248 := @135 (@246 @14) +@249 := @162 @9 +@250 := @249 @4 +@255 := {vs : @139} -> {ts : @140} -> (h : @244) -> (hs : @218) -> @248 @250 +@256 := @241 @59 +@257 := @136 @17 +@258 := @60 @228 +@259 := @258 @59 +@264 := {ts : @140} -> (h : @51) -> (hs : @257) -> @135 @259 @250 +@265 := @256 @90 +@266 := @60 @242 +@267 := @266 @59 +@268 := @135 @267 +@269 := @249 @90 +@272 := (h : @55) -> (hs : @137) -> @268 @269 +@273 := @265 @53 +@274 := @63 @59 +@276 := @135 @274 @269 +@277 := (hs : @137) -> @276 +@278 := @273 @134 +@280 := @135 @62 @269 +@281 := @214 @6 +@283 := @45 @245 @4 +@284 := @5 @149 +@285 := @60 @284 +@293 := {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @283) -> (hs : @218) -> @135 (@285 @14) @164 +@294 := @281 @9 +@300 := {vs : @139} -> {ts : @140} -> (h : @229 @9) -> (hs : @218) -> @234 @250 +@301 := @294 @62 +@302 := @268 @17 +@303 := @246 @259 +@304 := @135 @303 +@308 := {ts : @140} -> (h : @244) -> (hs : @302) -> @304 @250 +@309 := @301 @269 +@310 := @258 @267 +@311 := @135 @310 +@312 := @249 @269 +@315 := (h : @51) -> (hs : @276) -> @311 @312 +@316 := @309 @49 +@317 := @266 @274 +@318 := @135 @317 +@320 := (hs : @280) -> @318 @312 +@321 := @316 @278 +@322 := @135 @64 +@323 := @322 @312 +@324 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.denote +@326 := @324 @4 @17 +@327 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.__fits_0 +@329 := @327 @4 @17 +@332 := Coverage.Prims.fixedSmall @4 @17 +@333 := Option.{0} +@334 := @333 @3 +@335 := @66 @334 +@336 := @335 @334 +@337 := @335 @336 +@338 := @335 @337 +@341 := LexLeanPreservation.encOption @3 @5 +@343 := LexLeanPreservation.encPair @334 +@346 := @343 @334 @341 @341 +@349 := @343 @336 @341 @346 +@352 := @343 @337 @341 @349 +@356 := @343 @338 @341 @352 @332 +@359 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.root @4 @17 +@360 := Bool +@361 := Ne.{1} +@362 := LexLeanPreservation.Obs +@363 := @361 @362 +@364 := LexLeanPreservation.Rel +@367 := @363 (@364 @17 @19) +@368 := LexLeanPreservation.Obs.stuck +@371 := (f : @360) -> (v : @56) -> @367 @368 +@373 := LexLeanPreservation.Rust.rel_ne_stuck @329 +@380 := (v : @56) -> @363 (@364 (@327 @14 @4) @19) @368 +@381 := @373 @356 +@385 := @363 (@364 @329 @356) @368 +@386 := @138 @68 +@387 := LexLeanPreservation.Rust.FunSem +@388 := #9 +@394 := (n : @65) -> @387 @388 @155 @149 @19 @141 +@395 := Eq.{1} +@396 := @333 @85 +@397 := @395 @396 +@404 := LexLeanRuntime.index (@138 @85) @85 (LexLeanRuntime.instIndexableList @85) +@408 := @397 (@404 (@86 @388) @141) +@409 := Option.some.{0} +@410 := @409 @85 +@411 := @410 @143 +@412 := @408 @411 +@413 := #10 +@417 := @110 @413 @388 @155 @143 +@418 := LexLeanTarget.TargetSyntax.Function.types +@419 := @418 @141 +@420 := @417 @419 +@421 := @333 @386 +@422 := @395 @421 +@423 := LexLeanTarget.TargetSemantics.bindAll +@424 := LexLeanTarget.TargetSyntax.Function.parameters +@429 := @422 (@423 (@424 @149) @141 @78) +@430 := @409 @386 +@431 := @430 @143 +@432 := @429 @431 +@433 := @333 @360 +@434 := @395 @433 +@435 := LexLeanPreservation.Rust.fnFallible +@436 := #11 +@439 := @434 (@435 @436 @388) +@440 := @409 @360 +@441 := @440 @143 +@442 := @439 @441 +@443 := LexLeanPreservation.RunConv +@444 := #13 +@448 := @443 @444 @413 @155 @143 +@450 := @363 @141 @368 +@451 := Exists.{1} +@452 := LexLeanPreservation.Rust.ROut +@453 := @451 @452 +@454 := And +@455 := LexLeanPreservation.Rust.RealizesFn +@459 := @454 (@455 @388 @155 @19) +@460 := LexLeanPreservation.Rust.RCI +@462 := @460 #15 +@463 := LexLeanPreservation.Rust.fnIdent +@464 := @463 @444 +@471 := (hne : @450) -> @453 (fun (ro : @452) => @459 (@462 @464 @436 @19)) +@486 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @386} -> + {F : @360} -> + {o : @362} -> + (hB : @394) -> + (hfn : @412) -> (hwt : @420) -> (hbind : @432) -> (hF : @442) -> (hA : @448) -> @471 +@488 := LexLeanPreservation.Rust.compose @0 +@489 := @387 @0 +@494 := (n : @65) -> @489 @155 @149 @19 @141 +@495 := @404 @87 +@498 := @397 (@495 @141) @411 +@502 := @121 @388 @155 @143 @419 +@503 := @443 @0 +@506 := @503 @413 @155 @143 +@520 := {c : @11} -> + {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @386} -> + {F : @360} -> + {o : @362} -> + (hB : @494) -> + (hfn : @498) -> (hwt : @502) -> (hbind : @432) -> (hF : @442) -> (hA : @506) -> @471 +@521 := @488 @1 +@522 := @489 @1 +@526 := (n : @65) -> @522 @149 @19 @141 +@529 := @129 @155 @143 @419 +@530 := @435 @1 +@533 := @434 (@530 @388) @441 +@534 := @460 @1 +@544 := (hbind : @432) -> + (hF : @533) -> (hA : @506) -> (hne : @450) -> @453 (fun (ro : @452) => @459 (@534 @464 @436 @19)) +@554 := {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @386} -> {F : @360} -> {o : @362} -> (hB : @526) -> (hfn : @498) -> (hwt : @529) -> @544 +@555 := @521 @2 +@557 := @522 @2 @19 +@559 := (n : @65) -> @557 @141 +@560 := @135 @143 +@561 := @560 @419 +@570 := {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @386} -> {F : @360} -> {o : @362} -> (hB : @559) -> (hfn : @498) -> (hwt : @561) -> @544 +@571 := @555 @75 +@573 := (n : @65) -> @557 @75 +@574 := @495 @75 +@575 := @397 @574 +@576 := @575 @411 +@577 := @530 @75 +@578 := @434 @577 +@579 := @578 @441 +@580 := @503 @75 +@582 := @580 @155 @143 +@584 := @534 (@463 @75) +@592 := (hF : @579) -> (hA : @582) -> (hne : @450) -> @453 (fun (ro : @452) => @459 (@584 @436 @19)) +@601 := {fn : @85} -> + {args : @139} -> + {env : @386} -> + {F : @360} -> {o : @362} -> (hB : @573) -> (hfn : @576) -> (hwt : @561) -> (hbind : @432) -> @592 +@602 := @571 @105 +@604 := @575 (@410 @105) +@605 := @418 @105 +@606 := @560 @605 +@608 := @423 (@424 @105) +@620 := {args : @139} -> + {env : @386} -> + {F : @360} -> + {o : @362} -> + (hB : @573) -> (hfn : @604) -> (hwt : @606) -> (hbind : @422 (@608 @141 @78) @431) -> @592 +@621 := @602 @64 +@623 := @285 (@232 @59) +@625 := @135 @623 @605 +@627 := @60 (@5 @155) +@629 := @627 (@285 @59) +@633 := @422 (@608 @629 @78) @431 +@635 := @60 (@5 @413) +@637 := @60 (@5 @388) +@639 := @635 (@637 @59) +@641 := @580 @639 @143 +@643 := @60 (@5 @444) +@646 := @60 (@5 #12) +@663 := {env : @386} -> + {F : @360} -> + {o : @362} -> + (hB : @573) -> + (hfn : @604) -> + (hwt : @625) -> + (hbind : @633) -> + (hF : @579) -> + (hA : @641) -> (hne : @450) -> @453 (fun (ro : @452) => @459 (@584 (@643 (@646 @59)) @19)) +@664 := @621 @83 +@666 := @232 (@246 @59) +@668 := @135 @666 @605 +@679 := @422 (@608 @623 @78) (@430 (@79 (@73 @231) (@79 (@76 @284) @78))) +@681 := @637 (@627 @59) +@683 := @580 @681 @143 +@685 := @60 (@5 @436) +@701 := {F : @360} -> + {o : @362} -> + (hB : @573) -> + (hfn : @604) -> + (hwt : @668) -> + (hbind : @679) -> + (hF : @579) -> + (hA : @683) -> (hne : @450) -> @453 (fun (ro : @452) => @459 (@584 (@646 (@685 @59)) @19)) +@702 := @664 @84 +@703 := @304 @605 +@714 := @422 (@608 @666 @78) (@430 (@79 (@73 @245) (@79 (@76 @231) @78))) +@716 := @578 (@440 @84) +@718 := @580 @629 @143 +@719 := @455 @84 +@737 := {o : @362} -> + (hB : @573) -> + (hfn : @604) -> + (hwt : @703) -> + (hbind : @714) -> + (hF : @716) -> + (hA : @718) -> + (hne : @450) -> @453 (fun (ro : @452) => @454 (@719 @155 @19) (@584 (@685 (@635 @59)) @19)) +@738 := @702 @326 +@739 := @311 @605 +@750 := @422 (@608 @303 @78) (@430 (@79 (@73 @228) (@79 (@76 @245) @78))) +@751 := @580 @623 +@753 := @324 @149 @141 +@754 := @751 @753 +@756 := @324 @155 @149 +@775 := (hB : @573) -> + (hfn : @604) -> + (hwt : @739) -> + (hbind : @750) -> + (hF : @716) -> + (hA : @754) -> + (hne : @363 @756 @368) -> + @453 (fun (ro : @452) => @454 (@719 (@324 @413 @388) @19) (@584 @639 @19)) +@776 := @738 @109 +@777 := @318 @605 +@788 := @422 (@608 @310 @78) (@430 (@79 (@73 @242) (@79 (@76 @228) @78))) +@789 := @580 @666 +@791 := @324 @141 @143 +@810 := (hfn : @604) -> + (hwt : @777) -> + (hbind : @788) -> + (hF : @716) -> + (hA : @789 @791) -> + (hne : @363 @753 @368) -> + @453 (fun (ro : @452) => @454 (@719 (@324 @388 @155) @19) (@584 @681 @19)) +@811 := Eq.refl.{1} +@814 := @776 (@811 @396 @574) +@815 := @322 @605 +@826 := @422 (@608 @317 @78) (@430 (@79 (@73 @6) (@79 (@76 @242) @78))) +@827 := @580 @303 +@829 := @324 @143 @145 +@845 := (hwt : @815) -> + (hbind : @826) -> + (hF : @716) -> + (hA : @827 @829) -> + (hne : @363 @791 @368) -> @453 (fun (ro : @452) => @454 (@719 @756 @19) (@584 @629 @19)) +@846 := @814 @321 +@848 := @608 @64 @78 +@851 := @422 @848 (@430 @83) +@852 := @580 @310 +@854 := @324 @145 @14 +@869 := (hbind : @851) -> + (hF : @716) -> + (hA : @852 @854) -> + (hne : @363 @829 @368) -> @453 (fun (ro : @452) => @454 (@719 @753 @19) (@584 @623 @19)) +@872 := @846 (@811 @421 @848) +@873 := @580 @317 +@875 := @324 @14 @4 +@889 := (hF : @716) -> + (hA : @873 @875) -> + (hne : @363 @854 @368) -> @453 (fun (ro : @452) => @454 (@719 @791 @19) (@584 @666 @19)) +@892 := @872 (@811 @433 @577) +@906 := (hA : @580 @64 @326) -> + (hne : @363 @875 @368) -> @453 (fun (ro : @452) => @454 (@719 @829 @19) (@584 @303 @19)) +@907 := @892 @359 +@918 := (hne : @363 @326 @368) -> @453 (fun (ro : @452) => @454 (@719 @854 @19) (@584 @310 @19)) +@919 := @907 @381 +@925 := @454 (@719 @875 @19) (@584 @317 @19) +@927 := @453 (fun (ro : @452) => @925) +@929 := @453 (fun (__e_ro : @452) => @925) +@934 := LexLeanPreservation.Rust.RepresentableL (@61 (@60 @20 @59)) +@935 := (__e_hrep : @934) -> @929 +@936 := fun (__e_hrep : @934) => @919 +@937 := (b : @3) -> @935 +@938 := fun (b : @3) => @936 +@939 := (a : @3) -> @937 +@940 := fun (a : @3) => @938 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustCore.lean deleted file mode 100644 index 06f6f44be..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int16) (b : Int32) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.i16 a), (_root_.LexLeanTarget.TargetSyntax.Value.i32 b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.i16 a), (_root_.LexLeanTarget.TargetSyntax.Value.i32 b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i16 a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i32 b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustCore.lex.tex new file mode 100644 index 000000000..e225f6780 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustCore.lex.tex @@ -0,0 +1,501 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore.root : @1000 := @1001 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore.flags +@3 := Int16 +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.i16 +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.fixed +@9 := @7 LexLeanTarget.TargetSyntax.IntKind.i16 +@10 := LexLeanTarget.TargetSyntax.Program +@11 := LexLeanPreservation.Rust.RCrate +@12 := LexLeanPreservation.Rust.Flags +@13 := LexLeanPreservation.Rust.WT +@14 := #3 +@16 := @13 @14 @4 +@17 := #1 +@18 := @16 @17 +@19 := #0 +@20 := @5 @19 +@26 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @3) -> @18 @20 @9 +@28 := LexLeanPreservation.Rust.wt_i16 @0 +@29 := @13 @0 +@31 := @29 @4 @17 +@36 := {c : @11} -> {A : @12} -> (x : @3) -> @31 @20 @9 +@37 := @28 @1 +@38 := @29 @1 +@39 := @38 @17 +@43 := {A : @12} -> (x : @3) -> @39 @20 @9 +@44 := @37 @2 +@45 := @38 @2 +@48 := (x : @3) -> @45 @20 @9 +@49 := @44 @4 +@51 := @45 @6 @9 +@52 := Int32 +@53 := LexLeanTarget.TargetSyntax.Value.i32 +@54 := @53 @17 +@56 := @7 LexLeanTarget.TargetSyntax.IntKind.i32 +@57 := @53 @19 +@63 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @52) -> @18 @57 @56 +@65 := LexLeanPreservation.Rust.wt_i32 @0 +@70 := {c : @11} -> {A : @12} -> (x : @52) -> @31 @57 @56 +@71 := @65 @1 +@75 := {A : @12} -> (x : @52) -> @39 @57 @56 +@76 := @71 @2 +@79 := (x : @52) -> @45 @57 @56 +@80 := @76 @17 +@82 := @45 @54 @56 +@83 := LexLeanTarget.TargetSyntax.Value +@84 := List.nil.{0} +@85 := List.cons.{0} +@86 := @84 @83 +@87 := @85 @83 +@89 := @87 @54 @86 +@91 := @87 @6 @89 +@92 := Nat +@93 := Prod.{0, 0} +@95 := @93 @92 @83 +@96 := 1 +@99 := Prod.mk.{0, 0} @92 @83 +@100 := @99 @96 +@101 := @100 @54 +@102 := 0 +@103 := @99 @102 +@104 := @103 @6 +@105 := @84 @95 +@106 := @85 @95 +@108 := @106 @104 @105 +@110 := @106 @101 @108 +@111 := Bool.false +@112 := LexLeanTarget.TargetSyntax.Function +@113 := LexLeanTarget.TargetSyntax.Program.functions +@114 := @113 @0 +@115 := LexLeanTarget.TargetSyntax.Ty +@116 := @84 @92 +@117 := @84 @115 +@118 := LexLeanTarget.TargetSyntax.Ty.unit +@119 := LexLeanTarget.TargetSyntax.Value.unit +@122 := LexLeanTarget.TargetSyntax.Expr.value @118 @119 +@127 := LexLeanTarget.TargetSyntax.Function.mk @116 @117 @118 @122 +@132 := List.getD.{0} @112 @114 @102 @127 +@136 := fun (__e_n : @92) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore.root @19 @102 +@137 := LexLeanPreservation.Rust.WTL +@145 := {p : @10} -> {c : @11} -> {A : @12} -> @137 @4 @17 @19 @86 @117 +@147 := LexLeanPreservation.Rust.wtl_nil @0 +@148 := @137 @0 +@154 := {c : @11} -> {A : @12} -> @148 @17 @19 @86 @117 +@155 := @147 @1 +@156 := @148 @1 +@160 := {A : @12} -> @156 @19 @86 @117 +@161 := @155 @2 +@162 := @156 @2 +@163 := @162 @86 +@164 := @163 @117 +@165 := List.{0} +@166 := @165 @83 +@167 := @165 @115 +@168 := #6 +@169 := @13 @168 +@170 := #5 +@171 := @169 @170 +@172 := #4 +@175 := @171 @172 @14 @4 +@176 := #7 +@181 := @137 @176 @168 @170 @4 @17 +@182 := #8 +@185 := @137 @182 @176 @168 +@187 := @87 @170 @14 +@188 := @185 @187 +@189 := @85 @115 +@191 := @189 @172 @4 +@201 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {v : @83} -> {t : @115} -> {vs : @166} -> {ts : @167} -> (h : @175) -> (hs : @181) -> @188 @191 +@203 := LexLeanPreservation.Rust.wtl_cons @0 +@223 := {c : @11} -> + {A : @12} -> + {v : @83} -> + {t : @115} -> + {vs : @166} -> + {ts : @167} -> + (h : @29 @170 @172 @14 @4) -> (hs : @148 @168 @170 @4 @17) -> @148 @176 @168 @187 @191 +@224 := @203 @1 +@240 := {A : @12} -> + {v : @83} -> + {t : @115} -> + {vs : @166} -> + {ts : @167} -> (h : @38 @172 @14 @4) -> (hs : @156 @170 @4 @17) -> @156 @168 @187 @191 +@241 := @224 @2 +@243 := @45 @14 @4 +@245 := @162 @4 @17 +@253 := {v : @83} -> + {t : @115} -> {vs : @166} -> {ts : @167} -> (h : @243) -> (hs : @245) -> @162 @187 @191 +@254 := @241 @54 +@255 := @53 @172 +@257 := @45 @255 @4 +@258 := @53 @168 +@259 := @87 @258 +@267 := {t : @115} -> + {vs : @166} -> {ts : @167} -> (h : @257) -> (hs : @245) -> @162 (@259 @14) @191 +@268 := @254 @56 +@269 := @53 @14 +@271 := @45 @269 @56 +@272 := @53 @170 +@273 := @87 @272 +@275 := @162 (@273 @14) +@276 := @189 @56 +@277 := @276 @4 +@282 := {vs : @166} -> {ts : @167} -> (h : @271) -> (hs : @245) -> @275 @277 +@283 := @268 @86 +@284 := @53 @4 +@286 := @45 @284 @56 +@287 := @163 @17 +@289 := @87 @255 @86 +@294 := {ts : @167} -> (h : @286) -> (hs : @287) -> @162 @289 @277 +@295 := @283 @117 +@297 := @87 @269 @86 +@298 := @162 @297 +@299 := @276 @117 +@302 := (h : @82) -> (hs : @164) -> @298 @299 +@303 := @295 @80 +@305 := @87 @284 @86 +@307 := @162 @305 @299 +@308 := (hs : @164) -> @307 +@309 := @303 @161 +@311 := @162 @89 @299 +@312 := @241 @6 +@313 := @5 @170 +@315 := @45 @313 @4 +@316 := @5 @176 +@317 := @87 @316 +@325 := {t : @115} -> + {vs : @166} -> {ts : @167} -> (h : @315) -> (hs : @245) -> @162 (@317 @14) @191 +@326 := @312 @9 +@327 := @5 @172 +@329 := @45 @327 @9 +@330 := @5 @168 +@331 := @87 @330 +@333 := @162 (@331 @14) +@334 := @189 @9 +@335 := @334 @4 +@340 := {vs : @166} -> {ts : @167} -> (h : @329) -> (hs : @245) -> @333 @335 +@341 := @326 @89 +@342 := @5 @14 +@344 := @45 @342 @9 +@345 := @298 @17 +@347 := @87 @313 @289 +@348 := @162 @347 +@352 := {ts : @167} -> (h : @344) -> (hs : @345) -> @348 @335 +@353 := @341 @299 +@355 := @87 @327 @297 +@356 := @162 @355 +@357 := @334 @299 +@360 := (h : @51) -> (hs : @307) -> @356 @357 +@361 := @353 @49 +@363 := @87 @342 @305 +@364 := @162 @363 +@366 := (hs : @311) -> @364 @357 +@367 := @361 @309 +@368 := @162 @91 +@369 := @368 @357 +@370 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.denote +@372 := @370 @4 @17 +@373 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.__fits_0 +@375 := @373 @4 @17 +@378 := Coverage.Prims.fixedMiddle @4 @17 +@379 := Option.{0} +@380 := @379 @3 +@381 := @379 @52 +@382 := Bool +@383 := @93 @381 +@384 := @383 @382 +@385 := @383 @384 +@386 := LexLeanPreservation.encOption +@388 := @386 @3 @5 +@390 := @386 @52 @53 +@391 := LexLeanTarget.TargetSyntax.Value.bool +@392 := LexLeanPreservation.encPair +@393 := @392 @381 +@396 := @393 @382 @390 @391 +@399 := @393 @384 @390 @396 +@404 := @392 @380 @385 @388 @399 @378 +@407 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.root @4 @17 +@408 := Ne.{1} +@409 := LexLeanPreservation.Obs +@410 := @408 @409 +@411 := LexLeanPreservation.Rel +@414 := @410 (@411 @17 @19) +@415 := LexLeanPreservation.Obs.stuck +@418 := (f : @382) -> (v : @83) -> @414 @415 +@420 := LexLeanPreservation.Rust.rel_ne_stuck @375 +@427 := (v : @83) -> @410 (@411 (@373 @14 @4) @19) @415 +@428 := @420 @404 +@432 := @410 (@411 @375 @404) @415 +@433 := @165 @95 +@434 := LexLeanPreservation.Rust.FunSem +@435 := #9 +@441 := (n : @92) -> @434 @435 @182 @176 @19 @168 +@442 := Eq.{1} +@443 := @379 @112 +@444 := @442 @443 +@451 := LexLeanRuntime.index (@165 @112) @112 (LexLeanRuntime.instIndexableList @112) +@455 := @444 (@451 (@113 @435) @168) +@456 := Option.some.{0} +@457 := @456 @112 +@458 := @457 @170 +@459 := @455 @458 +@460 := #10 +@464 := @137 @460 @435 @182 @170 +@465 := LexLeanTarget.TargetSyntax.Function.types +@466 := @465 @168 +@467 := @464 @466 +@468 := @379 @433 +@469 := @442 @468 +@470 := LexLeanTarget.TargetSemantics.bindAll +@471 := LexLeanTarget.TargetSyntax.Function.parameters +@476 := @469 (@470 (@471 @176) @168 @105) +@477 := @456 @433 +@478 := @477 @170 +@479 := @476 @478 +@480 := @379 @382 +@481 := @442 @480 +@482 := LexLeanPreservation.Rust.fnFallible +@483 := #11 +@486 := @481 (@482 @483 @435) +@487 := @456 @382 +@488 := @487 @170 +@489 := @486 @488 +@490 := LexLeanPreservation.RunConv +@491 := #13 +@495 := @490 @491 @460 @182 @170 +@497 := @410 @168 @415 +@498 := Exists.{1} +@499 := LexLeanPreservation.Rust.ROut +@500 := @498 @499 +@501 := And +@502 := LexLeanPreservation.Rust.RealizesFn +@506 := @501 (@502 @435 @182 @19) +@507 := LexLeanPreservation.Rust.RCI +@509 := @507 #15 +@510 := LexLeanPreservation.Rust.fnIdent +@511 := @510 @491 +@518 := (hne : @497) -> @500 (fun (ro : @499) => @506 (@509 @511 @483 @19)) +@533 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {f : @92} -> + {fn : @112} -> + {args : @166} -> + {env : @433} -> + {F : @382} -> + {o : @409} -> + (hB : @441) -> + (hfn : @459) -> (hwt : @467) -> (hbind : @479) -> (hF : @489) -> (hA : @495) -> @518 +@535 := LexLeanPreservation.Rust.compose @0 +@536 := @434 @0 +@541 := (n : @92) -> @536 @182 @176 @19 @168 +@542 := @451 @114 +@545 := @444 (@542 @168) @458 +@549 := @148 @435 @182 @170 @466 +@550 := @490 @0 +@553 := @550 @460 @182 @170 +@567 := {c : @11} -> + {A : @12} -> + {f : @92} -> + {fn : @112} -> + {args : @166} -> + {env : @433} -> + {F : @382} -> + {o : @409} -> + (hB : @541) -> + (hfn : @545) -> (hwt : @549) -> (hbind : @479) -> (hF : @489) -> (hA : @553) -> @518 +@568 := @535 @1 +@569 := @536 @1 +@573 := (n : @92) -> @569 @176 @19 @168 +@576 := @156 @182 @170 @466 +@577 := @482 @1 +@580 := @481 (@577 @435) @488 +@581 := @507 @1 +@591 := (hbind : @479) -> + (hF : @580) -> (hA : @553) -> (hne : @497) -> @500 (fun (ro : @499) => @506 (@581 @511 @483 @19)) +@601 := {A : @12} -> + {f : @92} -> + {fn : @112} -> + {args : @166} -> + {env : @433} -> {F : @382} -> {o : @409} -> (hB : @573) -> (hfn : @545) -> (hwt : @576) -> @591 +@602 := @568 @2 +@604 := @569 @2 @19 +@606 := (n : @92) -> @604 @168 +@607 := @162 @170 +@608 := @607 @466 +@617 := {f : @92} -> + {fn : @112} -> + {args : @166} -> + {env : @433} -> {F : @382} -> {o : @409} -> (hB : @606) -> (hfn : @545) -> (hwt : @608) -> @591 +@618 := @602 @102 +@620 := (n : @92) -> @604 @102 +@621 := @542 @102 +@622 := @444 @621 +@623 := @622 @458 +@624 := @577 @102 +@625 := @481 @624 +@626 := @625 @488 +@627 := @550 @102 +@629 := @627 @182 @170 +@631 := @581 (@510 @102) +@639 := (hF : @626) -> (hA : @629) -> (hne : @497) -> @500 (fun (ro : @499) => @506 (@631 @483 @19)) +@648 := {fn : @112} -> + {args : @166} -> + {env : @433} -> + {F : @382} -> {o : @409} -> (hB : @620) -> (hfn : @623) -> (hwt : @608) -> (hbind : @479) -> @639 +@649 := @618 @132 +@651 := @622 (@457 @132) +@652 := @465 @132 +@653 := @607 @652 +@655 := @470 (@471 @132) +@667 := {args : @166} -> + {env : @433} -> + {F : @382} -> + {o : @409} -> + (hB : @620) -> (hfn : @651) -> (hwt : @653) -> (hbind : @469 (@655 @168 @105) @478) -> @639 +@668 := @649 @91 +@670 := @317 (@259 @86) +@672 := @162 @670 @652 +@678 := @87 (@5 @182) (@87 (@53 @176) @86) +@682 := @469 (@655 @678 @105) @478 +@688 := @87 (@5 @460) (@87 (@53 @435) @86) +@690 := @627 @688 @170 +@692 := @87 (@5 @491) +@693 := #12 +@712 := {env : @433} -> + {F : @382} -> + {o : @409} -> + (hB : @620) -> + (hfn : @651) -> + (hwt : @672) -> + (hbind : @682) -> + (hF : @626) -> + (hA : @690) -> + (hne : @497) -> @500 (fun (ro : @499) => @506 (@631 (@692 (@87 (@53 @693) @86)) @19)) +@713 := @668 @110 +@715 := @331 (@273 @86) +@717 := @162 @715 @652 +@728 := @469 (@655 @670 @105) (@477 (@106 (@100 @258) (@106 (@103 @316) @105))) +@734 := @87 (@5 @435) (@87 (@53 @182) @86) +@756 := {F : @382} -> + {o : @409} -> + (hB : @620) -> + (hfn : @651) -> + (hwt : @717) -> + (hbind : @728) -> + (hF : @626) -> + (hA : @627 @734 @170) -> + (hne : @497) -> @500 (fun (ro : @499) => @506 (@631 (@87 (@5 @693) (@87 (@53 @483) @86)) @19)) +@757 := @713 @111 +@758 := @348 @652 +@769 := @469 (@655 @715 @105) (@477 (@106 (@100 @272) (@106 (@103 @330) @105))) +@771 := @625 (@487 @111) +@773 := @627 @678 @170 +@774 := @502 @111 +@796 := {o : @409} -> + (hB : @620) -> + (hfn : @651) -> + (hwt : @758) -> + (hbind : @769) -> + (hF : @771) -> + (hA : @773) -> + (hne : @497) -> + @500 (fun (ro : @499) => @501 (@774 @182 @19) (@631 (@87 (@5 @483) (@87 (@53 @460) @86)) @19)) +@797 := @757 @372 +@798 := @356 @652 +@809 := @469 (@655 @347 @105) (@477 (@106 (@100 @255) (@106 (@103 @313) @105))) +@810 := @627 @670 +@812 := @370 @176 @168 +@813 := @810 @812 +@815 := @370 @182 @176 +@834 := (hB : @620) -> + (hfn : @651) -> + (hwt : @798) -> + (hbind : @809) -> + (hF : @771) -> + (hA : @813) -> + (hne : @410 @815 @415) -> + @500 (fun (ro : @499) => @501 (@774 (@370 @460 @435) @19) (@631 @688 @19)) +@835 := @797 @136 +@836 := @364 @652 +@847 := @469 (@655 @355 @105) (@477 (@106 (@100 @269) (@106 (@103 @327) @105))) +@848 := @627 @715 +@850 := @370 @168 @170 +@869 := (hfn : @651) -> + (hwt : @836) -> + (hbind : @847) -> + (hF : @771) -> + (hA : @848 @850) -> + (hne : @410 @812 @415) -> + @500 (fun (ro : @499) => @501 (@774 (@370 @435 @182) @19) (@631 @734 @19)) +@870 := Eq.refl.{1} +@873 := @835 (@870 @443 @621) +@874 := @368 @652 +@885 := @469 (@655 @363 @105) (@477 (@106 (@100 @284) (@106 (@103 @342) @105))) +@886 := @627 @347 +@888 := @370 @170 @172 +@904 := (hwt : @874) -> + (hbind : @885) -> + (hF : @771) -> + (hA : @886 @888) -> + (hne : @410 @850 @415) -> @500 (fun (ro : @499) => @501 (@774 @815 @19) (@631 @678 @19)) +@905 := @873 @367 +@907 := @655 @91 @105 +@910 := @469 @907 (@477 @110) +@911 := @627 @355 +@913 := @370 @172 @14 +@928 := (hbind : @910) -> + (hF : @771) -> + (hA : @911 @913) -> + (hne : @410 @888 @415) -> @500 (fun (ro : @499) => @501 (@774 @812 @19) (@631 @670 @19)) +@931 := @905 (@870 @468 @907) +@932 := @627 @363 +@934 := @370 @14 @4 +@948 := (hF : @771) -> + (hA : @932 @934) -> + (hne : @410 @913 @415) -> @500 (fun (ro : @499) => @501 (@774 @850 @19) (@631 @715 @19)) +@951 := @931 (@870 @480 @624) +@965 := (hA : @627 @91 @372) -> + (hne : @410 @934 @415) -> @500 (fun (ro : @499) => @501 (@774 @888 @19) (@631 @347 @19)) +@966 := @951 @407 +@977 := (hne : @410 @372 @415) -> @500 (fun (ro : @499) => @501 (@774 @913 @19) (@631 @355 @19)) +@978 := @966 @428 +@984 := @501 (@774 @934 @19) (@631 @363 @19) +@986 := @500 (fun (ro : @499) => @984) +@988 := @500 (fun (__e_ro : @499) => @984) +@989 := LexLeanPreservation.Rust.RepresentableL +@990 := @5 @17 +@992 := @87 @57 @86 +@995 := @989 (@87 @990 @992) +@996 := (__e_hrep : @995) -> @988 +@997 := fun (__e_hrep : @995) => @978 +@998 := (b : @52) -> @996 +@999 := fun (b : @52) => @997 +@1000 := (a : @3) -> @998 +@1001 := fun (a : @3) => @999 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustStd.lean deleted file mode 100644 index 83123305d..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int16) (b : Int32) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.i16 a), (_root_.LexLeanTarget.TargetSyntax.Value.i32 b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.i16 a), (_root_.LexLeanTarget.TargetSyntax.Value.i32 b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i16 a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i32 b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustStd.lex.tex new file mode 100644 index 000000000..9a5f3a1e1 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustStd.lex.tex @@ -0,0 +1,501 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd.root : @1000 := @1001 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd.flags +@3 := Int16 +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.i16 +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.fixed +@9 := @7 LexLeanTarget.TargetSyntax.IntKind.i16 +@10 := LexLeanTarget.TargetSyntax.Program +@11 := LexLeanPreservation.Rust.RCrate +@12 := LexLeanPreservation.Rust.Flags +@13 := LexLeanPreservation.Rust.WT +@14 := #3 +@16 := @13 @14 @4 +@17 := #1 +@18 := @16 @17 +@19 := #0 +@20 := @5 @19 +@26 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @3) -> @18 @20 @9 +@28 := LexLeanPreservation.Rust.wt_i16 @0 +@29 := @13 @0 +@31 := @29 @4 @17 +@36 := {c : @11} -> {A : @12} -> (x : @3) -> @31 @20 @9 +@37 := @28 @1 +@38 := @29 @1 +@39 := @38 @17 +@43 := {A : @12} -> (x : @3) -> @39 @20 @9 +@44 := @37 @2 +@45 := @38 @2 +@48 := (x : @3) -> @45 @20 @9 +@49 := @44 @4 +@51 := @45 @6 @9 +@52 := Int32 +@53 := LexLeanTarget.TargetSyntax.Value.i32 +@54 := @53 @17 +@56 := @7 LexLeanTarget.TargetSyntax.IntKind.i32 +@57 := @53 @19 +@63 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @52) -> @18 @57 @56 +@65 := LexLeanPreservation.Rust.wt_i32 @0 +@70 := {c : @11} -> {A : @12} -> (x : @52) -> @31 @57 @56 +@71 := @65 @1 +@75 := {A : @12} -> (x : @52) -> @39 @57 @56 +@76 := @71 @2 +@79 := (x : @52) -> @45 @57 @56 +@80 := @76 @17 +@82 := @45 @54 @56 +@83 := LexLeanTarget.TargetSyntax.Value +@84 := List.nil.{0} +@85 := List.cons.{0} +@86 := @84 @83 +@87 := @85 @83 +@89 := @87 @54 @86 +@91 := @87 @6 @89 +@92 := Nat +@93 := Prod.{0, 0} +@95 := @93 @92 @83 +@96 := 1 +@99 := Prod.mk.{0, 0} @92 @83 +@100 := @99 @96 +@101 := @100 @54 +@102 := 0 +@103 := @99 @102 +@104 := @103 @6 +@105 := @84 @95 +@106 := @85 @95 +@108 := @106 @104 @105 +@110 := @106 @101 @108 +@111 := Bool.false +@112 := LexLeanTarget.TargetSyntax.Function +@113 := LexLeanTarget.TargetSyntax.Program.functions +@114 := @113 @0 +@115 := LexLeanTarget.TargetSyntax.Ty +@116 := @84 @92 +@117 := @84 @115 +@118 := LexLeanTarget.TargetSyntax.Ty.unit +@119 := LexLeanTarget.TargetSyntax.Value.unit +@122 := LexLeanTarget.TargetSyntax.Expr.value @118 @119 +@127 := LexLeanTarget.TargetSyntax.Function.mk @116 @117 @118 @122 +@132 := List.getD.{0} @112 @114 @102 @127 +@136 := fun (__e_n : @92) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd.root @19 @102 +@137 := LexLeanPreservation.Rust.WTL +@145 := {p : @10} -> {c : @11} -> {A : @12} -> @137 @4 @17 @19 @86 @117 +@147 := LexLeanPreservation.Rust.wtl_nil @0 +@148 := @137 @0 +@154 := {c : @11} -> {A : @12} -> @148 @17 @19 @86 @117 +@155 := @147 @1 +@156 := @148 @1 +@160 := {A : @12} -> @156 @19 @86 @117 +@161 := @155 @2 +@162 := @156 @2 +@163 := @162 @86 +@164 := @163 @117 +@165 := List.{0} +@166 := @165 @83 +@167 := @165 @115 +@168 := #6 +@169 := @13 @168 +@170 := #5 +@171 := @169 @170 +@172 := #4 +@175 := @171 @172 @14 @4 +@176 := #7 +@181 := @137 @176 @168 @170 @4 @17 +@182 := #8 +@185 := @137 @182 @176 @168 +@187 := @87 @170 @14 +@188 := @185 @187 +@189 := @85 @115 +@191 := @189 @172 @4 +@201 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {v : @83} -> {t : @115} -> {vs : @166} -> {ts : @167} -> (h : @175) -> (hs : @181) -> @188 @191 +@203 := LexLeanPreservation.Rust.wtl_cons @0 +@223 := {c : @11} -> + {A : @12} -> + {v : @83} -> + {t : @115} -> + {vs : @166} -> + {ts : @167} -> + (h : @29 @170 @172 @14 @4) -> (hs : @148 @168 @170 @4 @17) -> @148 @176 @168 @187 @191 +@224 := @203 @1 +@240 := {A : @12} -> + {v : @83} -> + {t : @115} -> + {vs : @166} -> + {ts : @167} -> (h : @38 @172 @14 @4) -> (hs : @156 @170 @4 @17) -> @156 @168 @187 @191 +@241 := @224 @2 +@243 := @45 @14 @4 +@245 := @162 @4 @17 +@253 := {v : @83} -> + {t : @115} -> {vs : @166} -> {ts : @167} -> (h : @243) -> (hs : @245) -> @162 @187 @191 +@254 := @241 @54 +@255 := @53 @172 +@257 := @45 @255 @4 +@258 := @53 @168 +@259 := @87 @258 +@267 := {t : @115} -> + {vs : @166} -> {ts : @167} -> (h : @257) -> (hs : @245) -> @162 (@259 @14) @191 +@268 := @254 @56 +@269 := @53 @14 +@271 := @45 @269 @56 +@272 := @53 @170 +@273 := @87 @272 +@275 := @162 (@273 @14) +@276 := @189 @56 +@277 := @276 @4 +@282 := {vs : @166} -> {ts : @167} -> (h : @271) -> (hs : @245) -> @275 @277 +@283 := @268 @86 +@284 := @53 @4 +@286 := @45 @284 @56 +@287 := @163 @17 +@289 := @87 @255 @86 +@294 := {ts : @167} -> (h : @286) -> (hs : @287) -> @162 @289 @277 +@295 := @283 @117 +@297 := @87 @269 @86 +@298 := @162 @297 +@299 := @276 @117 +@302 := (h : @82) -> (hs : @164) -> @298 @299 +@303 := @295 @80 +@305 := @87 @284 @86 +@307 := @162 @305 @299 +@308 := (hs : @164) -> @307 +@309 := @303 @161 +@311 := @162 @89 @299 +@312 := @241 @6 +@313 := @5 @170 +@315 := @45 @313 @4 +@316 := @5 @176 +@317 := @87 @316 +@325 := {t : @115} -> + {vs : @166} -> {ts : @167} -> (h : @315) -> (hs : @245) -> @162 (@317 @14) @191 +@326 := @312 @9 +@327 := @5 @172 +@329 := @45 @327 @9 +@330 := @5 @168 +@331 := @87 @330 +@333 := @162 (@331 @14) +@334 := @189 @9 +@335 := @334 @4 +@340 := {vs : @166} -> {ts : @167} -> (h : @329) -> (hs : @245) -> @333 @335 +@341 := @326 @89 +@342 := @5 @14 +@344 := @45 @342 @9 +@345 := @298 @17 +@347 := @87 @313 @289 +@348 := @162 @347 +@352 := {ts : @167} -> (h : @344) -> (hs : @345) -> @348 @335 +@353 := @341 @299 +@355 := @87 @327 @297 +@356 := @162 @355 +@357 := @334 @299 +@360 := (h : @51) -> (hs : @307) -> @356 @357 +@361 := @353 @49 +@363 := @87 @342 @305 +@364 := @162 @363 +@366 := (hs : @311) -> @364 @357 +@367 := @361 @309 +@368 := @162 @91 +@369 := @368 @357 +@370 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.denote +@372 := @370 @4 @17 +@373 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.__fits_0 +@375 := @373 @4 @17 +@378 := Coverage.Prims.fixedMiddle @4 @17 +@379 := Option.{0} +@380 := @379 @3 +@381 := @379 @52 +@382 := Bool +@383 := @93 @381 +@384 := @383 @382 +@385 := @383 @384 +@386 := LexLeanPreservation.encOption +@388 := @386 @3 @5 +@390 := @386 @52 @53 +@391 := LexLeanTarget.TargetSyntax.Value.bool +@392 := LexLeanPreservation.encPair +@393 := @392 @381 +@396 := @393 @382 @390 @391 +@399 := @393 @384 @390 @396 +@404 := @392 @380 @385 @388 @399 @378 +@407 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.root @4 @17 +@408 := Ne.{1} +@409 := LexLeanPreservation.Obs +@410 := @408 @409 +@411 := LexLeanPreservation.Rel +@414 := @410 (@411 @17 @19) +@415 := LexLeanPreservation.Obs.stuck +@418 := (f : @382) -> (v : @83) -> @414 @415 +@420 := LexLeanPreservation.Rust.rel_ne_stuck @375 +@427 := (v : @83) -> @410 (@411 (@373 @14 @4) @19) @415 +@428 := @420 @404 +@432 := @410 (@411 @375 @404) @415 +@433 := @165 @95 +@434 := LexLeanPreservation.Rust.FunSem +@435 := #9 +@441 := (n : @92) -> @434 @435 @182 @176 @19 @168 +@442 := Eq.{1} +@443 := @379 @112 +@444 := @442 @443 +@451 := LexLeanRuntime.index (@165 @112) @112 (LexLeanRuntime.instIndexableList @112) +@455 := @444 (@451 (@113 @435) @168) +@456 := Option.some.{0} +@457 := @456 @112 +@458 := @457 @170 +@459 := @455 @458 +@460 := #10 +@464 := @137 @460 @435 @182 @170 +@465 := LexLeanTarget.TargetSyntax.Function.types +@466 := @465 @168 +@467 := @464 @466 +@468 := @379 @433 +@469 := @442 @468 +@470 := LexLeanTarget.TargetSemantics.bindAll +@471 := LexLeanTarget.TargetSyntax.Function.parameters +@476 := @469 (@470 (@471 @176) @168 @105) +@477 := @456 @433 +@478 := @477 @170 +@479 := @476 @478 +@480 := @379 @382 +@481 := @442 @480 +@482 := LexLeanPreservation.Rust.fnFallible +@483 := #11 +@486 := @481 (@482 @483 @435) +@487 := @456 @382 +@488 := @487 @170 +@489 := @486 @488 +@490 := LexLeanPreservation.RunConv +@491 := #13 +@495 := @490 @491 @460 @182 @170 +@497 := @410 @168 @415 +@498 := Exists.{1} +@499 := LexLeanPreservation.Rust.ROut +@500 := @498 @499 +@501 := And +@502 := LexLeanPreservation.Rust.RealizesFn +@506 := @501 (@502 @435 @182 @19) +@507 := LexLeanPreservation.Rust.RCI +@509 := @507 #15 +@510 := LexLeanPreservation.Rust.fnIdent +@511 := @510 @491 +@518 := (hne : @497) -> @500 (fun (ro : @499) => @506 (@509 @511 @483 @19)) +@533 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {f : @92} -> + {fn : @112} -> + {args : @166} -> + {env : @433} -> + {F : @382} -> + {o : @409} -> + (hB : @441) -> + (hfn : @459) -> (hwt : @467) -> (hbind : @479) -> (hF : @489) -> (hA : @495) -> @518 +@535 := LexLeanPreservation.Rust.compose @0 +@536 := @434 @0 +@541 := (n : @92) -> @536 @182 @176 @19 @168 +@542 := @451 @114 +@545 := @444 (@542 @168) @458 +@549 := @148 @435 @182 @170 @466 +@550 := @490 @0 +@553 := @550 @460 @182 @170 +@567 := {c : @11} -> + {A : @12} -> + {f : @92} -> + {fn : @112} -> + {args : @166} -> + {env : @433} -> + {F : @382} -> + {o : @409} -> + (hB : @541) -> + (hfn : @545) -> (hwt : @549) -> (hbind : @479) -> (hF : @489) -> (hA : @553) -> @518 +@568 := @535 @1 +@569 := @536 @1 +@573 := (n : @92) -> @569 @176 @19 @168 +@576 := @156 @182 @170 @466 +@577 := @482 @1 +@580 := @481 (@577 @435) @488 +@581 := @507 @1 +@591 := (hbind : @479) -> + (hF : @580) -> (hA : @553) -> (hne : @497) -> @500 (fun (ro : @499) => @506 (@581 @511 @483 @19)) +@601 := {A : @12} -> + {f : @92} -> + {fn : @112} -> + {args : @166} -> + {env : @433} -> {F : @382} -> {o : @409} -> (hB : @573) -> (hfn : @545) -> (hwt : @576) -> @591 +@602 := @568 @2 +@604 := @569 @2 @19 +@606 := (n : @92) -> @604 @168 +@607 := @162 @170 +@608 := @607 @466 +@617 := {f : @92} -> + {fn : @112} -> + {args : @166} -> + {env : @433} -> {F : @382} -> {o : @409} -> (hB : @606) -> (hfn : @545) -> (hwt : @608) -> @591 +@618 := @602 @102 +@620 := (n : @92) -> @604 @102 +@621 := @542 @102 +@622 := @444 @621 +@623 := @622 @458 +@624 := @577 @102 +@625 := @481 @624 +@626 := @625 @488 +@627 := @550 @102 +@629 := @627 @182 @170 +@631 := @581 (@510 @102) +@639 := (hF : @626) -> (hA : @629) -> (hne : @497) -> @500 (fun (ro : @499) => @506 (@631 @483 @19)) +@648 := {fn : @112} -> + {args : @166} -> + {env : @433} -> + {F : @382} -> {o : @409} -> (hB : @620) -> (hfn : @623) -> (hwt : @608) -> (hbind : @479) -> @639 +@649 := @618 @132 +@651 := @622 (@457 @132) +@652 := @465 @132 +@653 := @607 @652 +@655 := @470 (@471 @132) +@667 := {args : @166} -> + {env : @433} -> + {F : @382} -> + {o : @409} -> + (hB : @620) -> (hfn : @651) -> (hwt : @653) -> (hbind : @469 (@655 @168 @105) @478) -> @639 +@668 := @649 @91 +@670 := @317 (@259 @86) +@672 := @162 @670 @652 +@678 := @87 (@5 @182) (@87 (@53 @176) @86) +@682 := @469 (@655 @678 @105) @478 +@688 := @87 (@5 @460) (@87 (@53 @435) @86) +@690 := @627 @688 @170 +@692 := @87 (@5 @491) +@693 := #12 +@712 := {env : @433} -> + {F : @382} -> + {o : @409} -> + (hB : @620) -> + (hfn : @651) -> + (hwt : @672) -> + (hbind : @682) -> + (hF : @626) -> + (hA : @690) -> + (hne : @497) -> @500 (fun (ro : @499) => @506 (@631 (@692 (@87 (@53 @693) @86)) @19)) +@713 := @668 @110 +@715 := @331 (@273 @86) +@717 := @162 @715 @652 +@728 := @469 (@655 @670 @105) (@477 (@106 (@100 @258) (@106 (@103 @316) @105))) +@734 := @87 (@5 @435) (@87 (@53 @182) @86) +@756 := {F : @382} -> + {o : @409} -> + (hB : @620) -> + (hfn : @651) -> + (hwt : @717) -> + (hbind : @728) -> + (hF : @626) -> + (hA : @627 @734 @170) -> + (hne : @497) -> @500 (fun (ro : @499) => @506 (@631 (@87 (@5 @693) (@87 (@53 @483) @86)) @19)) +@757 := @713 @111 +@758 := @348 @652 +@769 := @469 (@655 @715 @105) (@477 (@106 (@100 @272) (@106 (@103 @330) @105))) +@771 := @625 (@487 @111) +@773 := @627 @678 @170 +@774 := @502 @111 +@796 := {o : @409} -> + (hB : @620) -> + (hfn : @651) -> + (hwt : @758) -> + (hbind : @769) -> + (hF : @771) -> + (hA : @773) -> + (hne : @497) -> + @500 (fun (ro : @499) => @501 (@774 @182 @19) (@631 (@87 (@5 @483) (@87 (@53 @460) @86)) @19)) +@797 := @757 @372 +@798 := @356 @652 +@809 := @469 (@655 @347 @105) (@477 (@106 (@100 @255) (@106 (@103 @313) @105))) +@810 := @627 @670 +@812 := @370 @176 @168 +@813 := @810 @812 +@815 := @370 @182 @176 +@834 := (hB : @620) -> + (hfn : @651) -> + (hwt : @798) -> + (hbind : @809) -> + (hF : @771) -> + (hA : @813) -> + (hne : @410 @815 @415) -> + @500 (fun (ro : @499) => @501 (@774 (@370 @460 @435) @19) (@631 @688 @19)) +@835 := @797 @136 +@836 := @364 @652 +@847 := @469 (@655 @355 @105) (@477 (@106 (@100 @269) (@106 (@103 @327) @105))) +@848 := @627 @715 +@850 := @370 @168 @170 +@869 := (hfn : @651) -> + (hwt : @836) -> + (hbind : @847) -> + (hF : @771) -> + (hA : @848 @850) -> + (hne : @410 @812 @415) -> + @500 (fun (ro : @499) => @501 (@774 (@370 @435 @182) @19) (@631 @734 @19)) +@870 := Eq.refl.{1} +@873 := @835 (@870 @443 @621) +@874 := @368 @652 +@885 := @469 (@655 @363 @105) (@477 (@106 (@100 @284) (@106 (@103 @342) @105))) +@886 := @627 @347 +@888 := @370 @170 @172 +@904 := (hwt : @874) -> + (hbind : @885) -> + (hF : @771) -> + (hA : @886 @888) -> + (hne : @410 @850 @415) -> @500 (fun (ro : @499) => @501 (@774 @815 @19) (@631 @678 @19)) +@905 := @873 @367 +@907 := @655 @91 @105 +@910 := @469 @907 (@477 @110) +@911 := @627 @355 +@913 := @370 @172 @14 +@928 := (hbind : @910) -> + (hF : @771) -> + (hA : @911 @913) -> + (hne : @410 @888 @415) -> @500 (fun (ro : @499) => @501 (@774 @812 @19) (@631 @670 @19)) +@931 := @905 (@870 @468 @907) +@932 := @627 @363 +@934 := @370 @14 @4 +@948 := (hF : @771) -> + (hA : @932 @934) -> + (hne : @410 @913 @415) -> @500 (fun (ro : @499) => @501 (@774 @850 @19) (@631 @715 @19)) +@951 := @931 (@870 @480 @624) +@965 := (hA : @627 @91 @372) -> + (hne : @410 @934 @415) -> @500 (fun (ro : @499) => @501 (@774 @888 @19) (@631 @347 @19)) +@966 := @951 @407 +@977 := (hne : @410 @372 @415) -> @500 (fun (ro : @499) => @501 (@774 @913 @19) (@631 @355 @19)) +@978 := @966 @428 +@984 := @501 (@774 @934 @19) (@631 @363 @19) +@986 := @500 (fun (ro : @499) => @984) +@988 := @500 (fun (__e_ro : @499) => @984) +@989 := LexLeanPreservation.Rust.RepresentableL +@990 := @5 @17 +@992 := @87 @57 @86 +@995 := @989 (@87 @990 @992) +@996 := (__e_hrep : @995) -> @988 +@997 := fun (__e_hrep : @995) => @978 +@998 := (b : @52) -> @996 +@999 := fun (b : @52) => @997 +@1000 := (a : @3) -> @998 +@1001 := fun (a : @3) => @999 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustCore.lean deleted file mode 100644 index 760707828..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int64) (b : Int64) (c : UInt64) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.i64 a), (_root_.LexLeanTarget.TargetSyntax.Value.i64 b), (_root_.LexLeanTarget.TargetSyntax.Value.u64 c)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.denote a b c) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.i64 a), (_root_.LexLeanTarget.TargetSyntax.Value.i64 b), (_root_.LexLeanTarget.TargetSyntax.Value.u64 c)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i64 a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i64 b) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u64 c) _root_.LexLeanPreservation.Rust.wtl_nil))) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.root a b c) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustCore.lex.tex new file mode 100644 index 000000000..8480e4291 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustCore.lex.tex @@ -0,0 +1,543 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore.root : @1096 := @1097 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore.flags +@3 := Int64 +@4 := #3 +@5 := LexLeanTarget.TargetSyntax.Value.i64 +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.fixed +@9 := @7 LexLeanTarget.TargetSyntax.IntKind.i64 +@10 := LexLeanTarget.TargetSyntax.Program +@11 := LexLeanPreservation.Rust.RCrate +@12 := LexLeanPreservation.Rust.Flags +@13 := LexLeanPreservation.Rust.WT +@14 := @13 @4 +@15 := #2 +@16 := @14 @15 +@17 := #1 +@18 := @16 @17 +@19 := #0 +@20 := @5 @19 +@26 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @3) -> @18 @20 @9 +@28 := LexLeanPreservation.Rust.wt_i64 @0 +@29 := @13 @0 +@31 := @29 @15 @17 +@36 := {c : @11} -> {A : @12} -> (x : @3) -> @31 @20 @9 +@37 := @28 @1 +@38 := @29 @1 +@39 := @38 @17 +@43 := {A : @12} -> (x : @3) -> @39 @20 @9 +@44 := @37 @2 +@45 := @38 @2 +@48 := (x : @3) -> @45 @20 @9 +@49 := @44 @4 +@51 := @45 @6 @9 +@52 := @5 @15 +@53 := @44 @15 +@55 := @45 @52 @9 +@56 := UInt64 +@57 := LexLeanTarget.TargetSyntax.Value.u64 +@58 := @57 @17 +@60 := @7 LexLeanTarget.TargetSyntax.IntKind.u64 +@61 := @57 @19 +@67 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @56) -> @18 @61 @60 +@69 := LexLeanPreservation.Rust.wt_u64 @0 +@74 := {c : @11} -> {A : @12} -> (x : @56) -> @31 @61 @60 +@75 := @69 @1 +@79 := {A : @12} -> (x : @56) -> @39 @61 @60 +@80 := @75 @2 +@83 := (x : @56) -> @45 @61 @60 +@84 := @80 @17 +@86 := @45 @58 @60 +@87 := LexLeanTarget.TargetSyntax.Value +@88 := List.nil.{0} +@89 := List.cons.{0} +@90 := @88 @87 +@91 := @89 @87 +@93 := @91 @58 @90 +@94 := @91 @52 +@95 := @94 @93 +@96 := @91 @6 +@97 := @96 @95 +@98 := Nat +@99 := Prod.{0, 0} +@101 := @99 @98 @87 +@102 := 2 +@105 := Prod.mk.{0, 0} @98 @87 +@106 := @105 @102 +@107 := @106 @58 +@109 := @105 1 +@110 := @109 @52 +@111 := 0 +@112 := @105 @111 +@113 := @112 @6 +@114 := @88 @101 +@115 := @89 @101 +@117 := @115 @113 @114 +@119 := @115 @110 @117 +@121 := @115 @107 @119 +@122 := Bool.false +@123 := LexLeanTarget.TargetSyntax.Function +@124 := LexLeanTarget.TargetSyntax.Program.functions +@125 := @124 @0 +@126 := LexLeanTarget.TargetSyntax.Ty +@127 := @88 @98 +@128 := @88 @126 +@129 := LexLeanTarget.TargetSyntax.Ty.unit +@130 := LexLeanTarget.TargetSyntax.Value.unit +@133 := LexLeanTarget.TargetSyntax.Expr.value @129 @130 +@138 := LexLeanTarget.TargetSyntax.Function.mk @127 @128 @129 @133 +@143 := List.getD.{0} @123 @125 @111 @138 +@147 := fun (__e_n : @98) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore.root @19 @111 +@148 := LexLeanPreservation.Rust.WTL +@156 := {p : @10} -> {c : @11} -> {A : @12} -> @148 @15 @17 @19 @90 @128 +@158 := LexLeanPreservation.Rust.wtl_nil @0 +@159 := @148 @0 +@165 := {c : @11} -> {A : @12} -> @159 @17 @19 @90 @128 +@166 := @158 @1 +@167 := @159 @1 +@171 := {A : @12} -> @167 @19 @90 @128 +@172 := @166 @2 +@173 := @167 @2 +@174 := @173 @90 +@175 := @174 @128 +@176 := List.{0} +@177 := @176 @87 +@178 := @176 @126 +@179 := #6 +@180 := @13 @179 +@181 := #5 +@182 := @180 @181 +@183 := #4 +@186 := @182 @183 @4 @15 +@187 := #7 +@192 := @148 @187 @179 @181 @15 @17 +@193 := #8 +@196 := @148 @193 @187 @179 +@198 := @91 @181 @4 +@199 := @196 @198 +@200 := @89 @126 +@202 := @200 @183 @15 +@212 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {v : @87} -> {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @186) -> (hs : @192) -> @199 @202 +@214 := LexLeanPreservation.Rust.wtl_cons @0 +@234 := {c : @11} -> + {A : @12} -> + {v : @87} -> + {t : @126} -> + {vs : @177} -> + {ts : @178} -> + (h : @29 @181 @183 @4 @15) -> (hs : @159 @179 @181 @15 @17) -> @159 @187 @179 @198 @202 +@235 := @214 @1 +@251 := {A : @12} -> + {v : @87} -> + {t : @126} -> + {vs : @177} -> + {ts : @178} -> (h : @38 @183 @4 @15) -> (hs : @167 @181 @15 @17) -> @167 @179 @198 @202 +@252 := @235 @2 +@254 := @45 @4 @15 +@256 := @173 @15 @17 +@264 := {v : @87} -> + {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @254) -> (hs : @256) -> @173 @198 @202 +@265 := @252 @58 +@266 := @57 @183 +@268 := @45 @266 @15 +@269 := @57 @179 +@270 := @91 @269 +@278 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @268) -> (hs : @256) -> @173 (@270 @4) @202 +@279 := @265 @60 +@280 := @57 @4 +@282 := @45 @280 @60 +@283 := @57 @181 +@284 := @91 @283 +@286 := @173 (@284 @4) +@287 := @200 @60 +@288 := @287 @15 +@293 := {vs : @177} -> {ts : @178} -> (h : @282) -> (hs : @256) -> @286 @288 +@294 := @279 @90 +@295 := @57 @15 +@297 := @45 @295 @60 +@298 := @174 @17 +@300 := @91 @266 @90 +@305 := {ts : @178} -> (h : @297) -> (hs : @298) -> @173 @300 @288 +@306 := @294 @128 +@308 := @91 @280 @90 +@309 := @173 @308 +@310 := @287 @128 +@313 := (h : @86) -> (hs : @175) -> @309 @310 +@314 := @306 @84 +@316 := @91 @295 @90 +@318 := @173 @316 @310 +@319 := (hs : @175) -> @318 +@320 := @314 @172 +@322 := @173 @93 @310 +@323 := @252 @52 +@324 := @5 @181 +@325 := @45 @324 +@326 := @325 @15 +@327 := @5 @187 +@328 := @91 @327 +@330 := @173 (@328 @4) +@336 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @326) -> (hs : @256) -> @330 @202 +@337 := @323 @9 +@338 := @5 @183 +@340 := @45 @338 @9 +@341 := @5 @179 +@342 := @91 @341 +@344 := @173 (@342 @4) +@345 := @200 @9 +@346 := @345 @15 +@351 := {vs : @177} -> {ts : @178} -> (h : @340) -> (hs : @256) -> @344 @346 +@352 := @337 @93 +@353 := @309 @17 +@354 := @91 @324 +@355 := @354 @300 +@360 := {ts : @178} -> (h : @51) -> (hs : @353) -> @173 @355 @346 +@361 := @352 @310 +@362 := @91 @338 +@363 := @362 @308 +@364 := @173 @363 +@365 := @345 @310 +@368 := (h : @55) -> (hs : @318) -> @364 @365 +@369 := @361 @53 +@370 := @96 @316 +@372 := @173 @370 @365 +@373 := (hs : @322) -> @372 +@374 := @369 @320 +@376 := @173 @95 @365 +@377 := @252 @6 +@379 := @45 @341 @15 +@380 := @5 @193 +@381 := @91 @380 +@389 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @379) -> (hs : @256) -> @173 (@381 @4) @202 +@390 := @377 @9 +@396 := {vs : @177} -> {ts : @178} -> (h : @325 @9) -> (hs : @256) -> @330 @346 +@397 := @390 @95 +@398 := @364 @17 +@399 := @342 @355 +@400 := @173 @399 +@404 := {ts : @178} -> (h : @340) -> (hs : @398) -> @400 @346 +@405 := @397 @365 +@406 := @354 @363 +@407 := @173 @406 +@408 := @345 @365 +@411 := (h : @51) -> (hs : @372) -> @407 @408 +@412 := @405 @49 +@413 := @362 @370 +@414 := @173 @413 +@416 := (hs : @376) -> @414 @408 +@417 := @412 @374 +@418 := @173 @97 +@419 := @418 @408 +@420 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.denote +@423 := @420 @4 @15 @17 +@424 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.__fits_0 +@427 := @424 @4 @15 @17 +@431 := Coverage.Prims.fixedWide @4 @15 @17 +@432 := Option.{0} +@433 := @432 @3 +@434 := @432 @56 +@435 := @99 @433 +@436 := @435 @434 +@437 := @435 @436 +@438 := @435 @437 +@439 := @435 @438 +@440 := LexLeanPreservation.encOption +@442 := @440 @3 @5 +@444 := @440 @56 @57 +@446 := LexLeanPreservation.encPair @433 +@449 := @446 @434 @442 @444 +@452 := @446 @436 @442 @449 +@455 := @446 @437 @442 @452 +@458 := @446 @438 @442 @455 +@462 := @446 @439 @442 @458 @431 +@466 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.root @4 @15 @17 +@467 := Bool +@468 := Ne.{1} +@469 := LexLeanPreservation.Obs +@470 := @468 @469 +@471 := LexLeanPreservation.Rel +@474 := @470 (@471 @17 @19) +@475 := LexLeanPreservation.Obs.stuck +@478 := (f : @467) -> (v : @87) -> @474 @475 +@480 := LexLeanPreservation.Rust.rel_ne_stuck @427 +@488 := (v : @87) -> @470 (@471 (@424 @183 @4 @15) @19) @475 +@489 := @480 @462 +@493 := @470 (@471 @427 @462) @475 +@494 := @176 @101 +@495 := LexLeanPreservation.Rust.FunSem +@496 := #9 +@502 := (n : @98) -> @495 @496 @193 @187 @19 @179 +@503 := Eq.{1} +@504 := @432 @123 +@505 := @503 @504 +@512 := LexLeanRuntime.index (@176 @123) @123 (LexLeanRuntime.instIndexableList @123) +@516 := @505 (@512 (@124 @496) @179) +@517 := Option.some.{0} +@518 := @517 @123 +@519 := @518 @181 +@520 := @516 @519 +@521 := #10 +@525 := @148 @521 @496 @193 @181 +@526 := LexLeanTarget.TargetSyntax.Function.types +@527 := @526 @179 +@528 := @525 @527 +@529 := @432 @494 +@530 := @503 @529 +@531 := LexLeanTarget.TargetSemantics.bindAll +@532 := LexLeanTarget.TargetSyntax.Function.parameters +@537 := @530 (@531 (@532 @187) @179 @114) +@538 := @517 @494 +@539 := @538 @181 +@540 := @537 @539 +@541 := @432 @467 +@542 := @503 @541 +@543 := LexLeanPreservation.Rust.fnFallible +@544 := #11 +@547 := @542 (@543 @544 @496) +@548 := @517 @467 +@549 := @548 @181 +@550 := @547 @549 +@551 := LexLeanPreservation.RunConv +@552 := #13 +@556 := @551 @552 @521 @193 @181 +@558 := @470 @179 @475 +@559 := Exists.{1} +@560 := LexLeanPreservation.Rust.ROut +@561 := @559 @560 +@562 := And +@563 := LexLeanPreservation.Rust.RealizesFn +@567 := @562 (@563 @496 @193 @19) +@568 := LexLeanPreservation.Rust.RCI +@570 := @568 #15 +@571 := LexLeanPreservation.Rust.fnIdent +@572 := @571 @552 +@579 := (hne : @558) -> @561 (fun (ro : @560) => @567 (@570 @572 @544 @19)) +@594 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @494} -> + {F : @467} -> + {o : @469} -> + (hB : @502) -> + (hfn : @520) -> (hwt : @528) -> (hbind : @540) -> (hF : @550) -> (hA : @556) -> @579 +@596 := LexLeanPreservation.Rust.compose @0 +@597 := @495 @0 +@602 := (n : @98) -> @597 @193 @187 @19 @179 +@603 := @512 @125 +@606 := @505 (@603 @179) @519 +@610 := @159 @496 @193 @181 @527 +@611 := @551 @0 +@614 := @611 @521 @193 @181 +@628 := {c : @11} -> + {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @494} -> + {F : @467} -> + {o : @469} -> + (hB : @602) -> + (hfn : @606) -> (hwt : @610) -> (hbind : @540) -> (hF : @550) -> (hA : @614) -> @579 +@629 := @596 @1 +@630 := @597 @1 +@634 := (n : @98) -> @630 @187 @19 @179 +@637 := @167 @193 @181 @527 +@638 := @543 @1 +@641 := @542 (@638 @496) @549 +@642 := @568 @1 +@652 := (hbind : @540) -> + (hF : @641) -> (hA : @614) -> (hne : @558) -> @561 (fun (ro : @560) => @567 (@642 @572 @544 @19)) +@662 := {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @494} -> {F : @467} -> {o : @469} -> (hB : @634) -> (hfn : @606) -> (hwt : @637) -> @652 +@663 := @629 @2 +@665 := @630 @2 @19 +@667 := (n : @98) -> @665 @179 +@668 := @173 @181 +@669 := @668 @527 +@678 := {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @494} -> {F : @467} -> {o : @469} -> (hB : @667) -> (hfn : @606) -> (hwt : @669) -> @652 +@679 := @663 @111 +@681 := (n : @98) -> @665 @111 +@682 := @603 @111 +@683 := @505 @682 +@684 := @683 @519 +@685 := @638 @111 +@686 := @542 @685 +@687 := @686 @549 +@688 := @611 @111 +@690 := @688 @193 @181 +@692 := @642 (@571 @111) +@700 := (hF : @687) -> (hA : @690) -> (hne : @558) -> @561 (fun (ro : @560) => @567 (@692 @544 @19)) +@709 := {fn : @123} -> + {args : @177} -> + {env : @494} -> + {F : @467} -> {o : @469} -> (hB : @681) -> (hfn : @684) -> (hwt : @669) -> (hbind : @540) -> @700 +@710 := @679 @143 +@712 := @683 (@518 @143) +@713 := @526 @143 +@714 := @668 @713 +@716 := @531 (@532 @143) +@728 := {args : @177} -> + {env : @494} -> + {F : @467} -> + {o : @469} -> + (hB : @681) -> (hfn : @712) -> (hwt : @714) -> (hbind : @530 (@716 @179 @114) @539) -> @700 +@729 := @710 @97 +@732 := @381 (@328 (@270 @90)) +@734 := @173 @732 @713 +@736 := @91 (@5 @496) +@741 := @736 (@381 (@91 (@57 @187) @90)) +@745 := @530 (@716 @741 @114) @539 +@747 := @91 (@5 @544) +@749 := @91 (@5 @521) +@754 := @747 (@749 (@91 (@57 @496) @90)) +@756 := @688 @754 @181 +@759 := @91 (@5 #14) +@761 := @91 (@5 @552) +@762 := #12 +@782 := {env : @494} -> + {F : @467} -> + {o : @469} -> + (hB : @681) -> + (hfn : @712) -> + (hwt : @734) -> + (hbind : @745) -> + (hF : @687) -> + (hA : @756) -> + (hne : @558) -> @561 (fun (ro : @560) => @567 (@692 (@759 (@761 (@91 (@57 @762) @90))) @19)) +@783 := @729 @121 +@786 := @328 (@342 (@284 @90)) +@788 := @173 @786 @713 +@802 := @530 (@716 @732 @114) (@538 (@115 (@106 @269) (@115 (@109 @327) (@115 (@112 @380) @114)))) +@807 := @749 (@736 (@91 (@57 @193) @90)) +@809 := @688 @807 @181 +@811 := @91 (@5 @762) +@830 := {F : @467} -> + {o : @469} -> + (hB : @681) -> + (hfn : @712) -> + (hwt : @788) -> + (hbind : @802) -> + (hF : @687) -> + (hA : @809) -> + (hne : @558) -> @561 (fun (ro : @560) => @567 (@692 (@761 (@811 (@91 (@57 @544) @90))) @19)) +@831 := @783 @122 +@832 := @400 @713 +@846 := @530 (@716 @786 @114) (@538 (@115 (@106 @283) (@115 (@109 @341) (@115 (@112 @327) @114)))) +@848 := @686 (@548 @122) +@850 := @688 @741 @181 +@851 := @563 @122 +@872 := {o : @469} -> + (hB : @681) -> + (hfn : @712) -> + (hwt : @832) -> + (hbind : @846) -> + (hF : @848) -> + (hA : @850) -> + (hne : @558) -> + @561 (fun (ro : @560) => @562 (@851 @193 @19) (@692 (@811 (@747 (@91 (@57 @521) @90))) @19)) +@873 := @831 @423 +@874 := @407 @713 +@888 := @530 (@716 @399 @114) (@538 (@115 (@106 @266) (@115 (@109 @324) (@115 (@112 @341) @114)))) +@889 := @688 @732 +@892 := @420 @193 @187 @179 +@893 := @889 @892 +@896 := @420 @496 @193 @187 +@916 := (hB : @681) -> + (hfn : @712) -> + (hwt : @874) -> + (hbind : @888) -> + (hF : @848) -> + (hA : @893) -> + (hne : @470 @896 @475) -> + @561 (fun (ro : @560) => @562 (@851 (@420 @544 @521 @496) @19) (@692 @754 @19)) +@917 := @873 @147 +@918 := @414 @713 +@932 := @530 (@716 @406 @114) (@538 (@115 (@106 @280) (@115 (@109 @338) (@115 (@112 @324) @114)))) +@933 := @688 @786 +@936 := @420 @187 @179 @181 +@956 := (hfn : @712) -> + (hwt : @918) -> + (hbind : @932) -> + (hF : @848) -> + (hA : @933 @936) -> + (hne : @470 @892 @475) -> + @561 (fun (ro : @560) => @562 (@851 (@420 @521 @496 @193) @19) (@692 @807 @19)) +@957 := Eq.refl.{1} +@960 := @917 (@957 @504 @682) +@961 := @418 @713 +@975 := @530 (@716 @413 @114) (@538 (@115 (@106 @295) (@115 (@109 @6) (@115 (@112 @338) @114)))) +@976 := @688 @399 +@979 := @420 @179 @181 @183 +@995 := (hwt : @961) -> + (hbind : @975) -> + (hF : @848) -> + (hA : @976 @979) -> + (hne : @470 @936 @475) -> @561 (fun (ro : @560) => @562 (@851 @896 @19) (@692 @741 @19)) +@996 := @960 @417 +@998 := @716 @97 @114 +@1001 := @530 @998 (@538 @121) +@1002 := @688 @406 +@1005 := @420 @181 @183 @4 +@1020 := (hbind : @1001) -> + (hF : @848) -> + (hA : @1002 @1005) -> + (hne : @470 @979 @475) -> @561 (fun (ro : @560) => @562 (@851 @892 @19) (@692 @732 @19)) +@1023 := @996 (@957 @529 @998) +@1024 := @688 @413 +@1027 := @420 @183 @4 @15 +@1041 := (hF : @848) -> + (hA : @1024 @1027) -> + (hne : @470 @1005 @475) -> @561 (fun (ro : @560) => @562 (@851 @936 @19) (@692 @786 @19)) +@1044 := @1023 (@957 @541 @685) +@1058 := (hA : @688 @97 @423) -> + (hne : @470 @1027 @475) -> @561 (fun (ro : @560) => @562 (@851 @979 @19) (@692 @399 @19)) +@1059 := @1044 @466 +@1070 := (hne : @470 @423 @475) -> @561 (fun (ro : @560) => @562 (@851 @1005 @19) (@692 @406 @19)) +@1071 := @1059 @489 +@1077 := @562 (@851 @1027 @19) (@692 @413 @19) +@1079 := @561 (fun (ro : @560) => @1077) +@1081 := @561 (fun (__e_ro : @560) => @1077) +@1082 := LexLeanPreservation.Rust.RepresentableL +@1083 := @5 @17 +@1085 := @91 @61 @90 +@1089 := @1082 (@94 (@91 @1083 @1085)) +@1090 := (__e_hrep : @1089) -> @1081 +@1091 := fun (__e_hrep : @1089) => @1071 +@1092 := (c : @56) -> @1090 +@1093 := fun (c : @56) => @1091 +@1094 := (b : @3) -> @1092 +@1095 := fun (b : @3) => @1093 +@1096 := (a : @3) -> @1094 +@1097 := fun (a : @3) => @1095 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustStd.lean deleted file mode 100644 index 69febf691..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int64) (b : Int64) (c : UInt64) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.i64 a), (_root_.LexLeanTarget.TargetSyntax.Value.i64 b), (_root_.LexLeanTarget.TargetSyntax.Value.u64 c)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.denote a b c) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.i64 a), (_root_.LexLeanTarget.TargetSyntax.Value.i64 b), (_root_.LexLeanTarget.TargetSyntax.Value.u64 c)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i64 a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i64 b) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u64 c) _root_.LexLeanPreservation.Rust.wtl_nil))) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.root a b c) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustStd.lex.tex new file mode 100644 index 000000000..2e124a4cf --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustStd.lex.tex @@ -0,0 +1,543 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd.root : @1096 := @1097 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd.flags +@3 := Int64 +@4 := #3 +@5 := LexLeanTarget.TargetSyntax.Value.i64 +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.fixed +@9 := @7 LexLeanTarget.TargetSyntax.IntKind.i64 +@10 := LexLeanTarget.TargetSyntax.Program +@11 := LexLeanPreservation.Rust.RCrate +@12 := LexLeanPreservation.Rust.Flags +@13 := LexLeanPreservation.Rust.WT +@14 := @13 @4 +@15 := #2 +@16 := @14 @15 +@17 := #1 +@18 := @16 @17 +@19 := #0 +@20 := @5 @19 +@26 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @3) -> @18 @20 @9 +@28 := LexLeanPreservation.Rust.wt_i64 @0 +@29 := @13 @0 +@31 := @29 @15 @17 +@36 := {c : @11} -> {A : @12} -> (x : @3) -> @31 @20 @9 +@37 := @28 @1 +@38 := @29 @1 +@39 := @38 @17 +@43 := {A : @12} -> (x : @3) -> @39 @20 @9 +@44 := @37 @2 +@45 := @38 @2 +@48 := (x : @3) -> @45 @20 @9 +@49 := @44 @4 +@51 := @45 @6 @9 +@52 := @5 @15 +@53 := @44 @15 +@55 := @45 @52 @9 +@56 := UInt64 +@57 := LexLeanTarget.TargetSyntax.Value.u64 +@58 := @57 @17 +@60 := @7 LexLeanTarget.TargetSyntax.IntKind.u64 +@61 := @57 @19 +@67 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @56) -> @18 @61 @60 +@69 := LexLeanPreservation.Rust.wt_u64 @0 +@74 := {c : @11} -> {A : @12} -> (x : @56) -> @31 @61 @60 +@75 := @69 @1 +@79 := {A : @12} -> (x : @56) -> @39 @61 @60 +@80 := @75 @2 +@83 := (x : @56) -> @45 @61 @60 +@84 := @80 @17 +@86 := @45 @58 @60 +@87 := LexLeanTarget.TargetSyntax.Value +@88 := List.nil.{0} +@89 := List.cons.{0} +@90 := @88 @87 +@91 := @89 @87 +@93 := @91 @58 @90 +@94 := @91 @52 +@95 := @94 @93 +@96 := @91 @6 +@97 := @96 @95 +@98 := Nat +@99 := Prod.{0, 0} +@101 := @99 @98 @87 +@102 := 2 +@105 := Prod.mk.{0, 0} @98 @87 +@106 := @105 @102 +@107 := @106 @58 +@109 := @105 1 +@110 := @109 @52 +@111 := 0 +@112 := @105 @111 +@113 := @112 @6 +@114 := @88 @101 +@115 := @89 @101 +@117 := @115 @113 @114 +@119 := @115 @110 @117 +@121 := @115 @107 @119 +@122 := Bool.false +@123 := LexLeanTarget.TargetSyntax.Function +@124 := LexLeanTarget.TargetSyntax.Program.functions +@125 := @124 @0 +@126 := LexLeanTarget.TargetSyntax.Ty +@127 := @88 @98 +@128 := @88 @126 +@129 := LexLeanTarget.TargetSyntax.Ty.unit +@130 := LexLeanTarget.TargetSyntax.Value.unit +@133 := LexLeanTarget.TargetSyntax.Expr.value @129 @130 +@138 := LexLeanTarget.TargetSyntax.Function.mk @127 @128 @129 @133 +@143 := List.getD.{0} @123 @125 @111 @138 +@147 := fun (__e_n : @98) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd.root @19 @111 +@148 := LexLeanPreservation.Rust.WTL +@156 := {p : @10} -> {c : @11} -> {A : @12} -> @148 @15 @17 @19 @90 @128 +@158 := LexLeanPreservation.Rust.wtl_nil @0 +@159 := @148 @0 +@165 := {c : @11} -> {A : @12} -> @159 @17 @19 @90 @128 +@166 := @158 @1 +@167 := @159 @1 +@171 := {A : @12} -> @167 @19 @90 @128 +@172 := @166 @2 +@173 := @167 @2 +@174 := @173 @90 +@175 := @174 @128 +@176 := List.{0} +@177 := @176 @87 +@178 := @176 @126 +@179 := #6 +@180 := @13 @179 +@181 := #5 +@182 := @180 @181 +@183 := #4 +@186 := @182 @183 @4 @15 +@187 := #7 +@192 := @148 @187 @179 @181 @15 @17 +@193 := #8 +@196 := @148 @193 @187 @179 +@198 := @91 @181 @4 +@199 := @196 @198 +@200 := @89 @126 +@202 := @200 @183 @15 +@212 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {v : @87} -> {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @186) -> (hs : @192) -> @199 @202 +@214 := LexLeanPreservation.Rust.wtl_cons @0 +@234 := {c : @11} -> + {A : @12} -> + {v : @87} -> + {t : @126} -> + {vs : @177} -> + {ts : @178} -> + (h : @29 @181 @183 @4 @15) -> (hs : @159 @179 @181 @15 @17) -> @159 @187 @179 @198 @202 +@235 := @214 @1 +@251 := {A : @12} -> + {v : @87} -> + {t : @126} -> + {vs : @177} -> + {ts : @178} -> (h : @38 @183 @4 @15) -> (hs : @167 @181 @15 @17) -> @167 @179 @198 @202 +@252 := @235 @2 +@254 := @45 @4 @15 +@256 := @173 @15 @17 +@264 := {v : @87} -> + {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @254) -> (hs : @256) -> @173 @198 @202 +@265 := @252 @58 +@266 := @57 @183 +@268 := @45 @266 @15 +@269 := @57 @179 +@270 := @91 @269 +@278 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @268) -> (hs : @256) -> @173 (@270 @4) @202 +@279 := @265 @60 +@280 := @57 @4 +@282 := @45 @280 @60 +@283 := @57 @181 +@284 := @91 @283 +@286 := @173 (@284 @4) +@287 := @200 @60 +@288 := @287 @15 +@293 := {vs : @177} -> {ts : @178} -> (h : @282) -> (hs : @256) -> @286 @288 +@294 := @279 @90 +@295 := @57 @15 +@297 := @45 @295 @60 +@298 := @174 @17 +@300 := @91 @266 @90 +@305 := {ts : @178} -> (h : @297) -> (hs : @298) -> @173 @300 @288 +@306 := @294 @128 +@308 := @91 @280 @90 +@309 := @173 @308 +@310 := @287 @128 +@313 := (h : @86) -> (hs : @175) -> @309 @310 +@314 := @306 @84 +@316 := @91 @295 @90 +@318 := @173 @316 @310 +@319 := (hs : @175) -> @318 +@320 := @314 @172 +@322 := @173 @93 @310 +@323 := @252 @52 +@324 := @5 @181 +@325 := @45 @324 +@326 := @325 @15 +@327 := @5 @187 +@328 := @91 @327 +@330 := @173 (@328 @4) +@336 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @326) -> (hs : @256) -> @330 @202 +@337 := @323 @9 +@338 := @5 @183 +@340 := @45 @338 @9 +@341 := @5 @179 +@342 := @91 @341 +@344 := @173 (@342 @4) +@345 := @200 @9 +@346 := @345 @15 +@351 := {vs : @177} -> {ts : @178} -> (h : @340) -> (hs : @256) -> @344 @346 +@352 := @337 @93 +@353 := @309 @17 +@354 := @91 @324 +@355 := @354 @300 +@360 := {ts : @178} -> (h : @51) -> (hs : @353) -> @173 @355 @346 +@361 := @352 @310 +@362 := @91 @338 +@363 := @362 @308 +@364 := @173 @363 +@365 := @345 @310 +@368 := (h : @55) -> (hs : @318) -> @364 @365 +@369 := @361 @53 +@370 := @96 @316 +@372 := @173 @370 @365 +@373 := (hs : @322) -> @372 +@374 := @369 @320 +@376 := @173 @95 @365 +@377 := @252 @6 +@379 := @45 @341 @15 +@380 := @5 @193 +@381 := @91 @380 +@389 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @379) -> (hs : @256) -> @173 (@381 @4) @202 +@390 := @377 @9 +@396 := {vs : @177} -> {ts : @178} -> (h : @325 @9) -> (hs : @256) -> @330 @346 +@397 := @390 @95 +@398 := @364 @17 +@399 := @342 @355 +@400 := @173 @399 +@404 := {ts : @178} -> (h : @340) -> (hs : @398) -> @400 @346 +@405 := @397 @365 +@406 := @354 @363 +@407 := @173 @406 +@408 := @345 @365 +@411 := (h : @51) -> (hs : @372) -> @407 @408 +@412 := @405 @49 +@413 := @362 @370 +@414 := @173 @413 +@416 := (hs : @376) -> @414 @408 +@417 := @412 @374 +@418 := @173 @97 +@419 := @418 @408 +@420 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.denote +@423 := @420 @4 @15 @17 +@424 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.__fits_0 +@427 := @424 @4 @15 @17 +@431 := Coverage.Prims.fixedWide @4 @15 @17 +@432 := Option.{0} +@433 := @432 @3 +@434 := @432 @56 +@435 := @99 @433 +@436 := @435 @434 +@437 := @435 @436 +@438 := @435 @437 +@439 := @435 @438 +@440 := LexLeanPreservation.encOption +@442 := @440 @3 @5 +@444 := @440 @56 @57 +@446 := LexLeanPreservation.encPair @433 +@449 := @446 @434 @442 @444 +@452 := @446 @436 @442 @449 +@455 := @446 @437 @442 @452 +@458 := @446 @438 @442 @455 +@462 := @446 @439 @442 @458 @431 +@466 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.root @4 @15 @17 +@467 := Bool +@468 := Ne.{1} +@469 := LexLeanPreservation.Obs +@470 := @468 @469 +@471 := LexLeanPreservation.Rel +@474 := @470 (@471 @17 @19) +@475 := LexLeanPreservation.Obs.stuck +@478 := (f : @467) -> (v : @87) -> @474 @475 +@480 := LexLeanPreservation.Rust.rel_ne_stuck @427 +@488 := (v : @87) -> @470 (@471 (@424 @183 @4 @15) @19) @475 +@489 := @480 @462 +@493 := @470 (@471 @427 @462) @475 +@494 := @176 @101 +@495 := LexLeanPreservation.Rust.FunSem +@496 := #9 +@502 := (n : @98) -> @495 @496 @193 @187 @19 @179 +@503 := Eq.{1} +@504 := @432 @123 +@505 := @503 @504 +@512 := LexLeanRuntime.index (@176 @123) @123 (LexLeanRuntime.instIndexableList @123) +@516 := @505 (@512 (@124 @496) @179) +@517 := Option.some.{0} +@518 := @517 @123 +@519 := @518 @181 +@520 := @516 @519 +@521 := #10 +@525 := @148 @521 @496 @193 @181 +@526 := LexLeanTarget.TargetSyntax.Function.types +@527 := @526 @179 +@528 := @525 @527 +@529 := @432 @494 +@530 := @503 @529 +@531 := LexLeanTarget.TargetSemantics.bindAll +@532 := LexLeanTarget.TargetSyntax.Function.parameters +@537 := @530 (@531 (@532 @187) @179 @114) +@538 := @517 @494 +@539 := @538 @181 +@540 := @537 @539 +@541 := @432 @467 +@542 := @503 @541 +@543 := LexLeanPreservation.Rust.fnFallible +@544 := #11 +@547 := @542 (@543 @544 @496) +@548 := @517 @467 +@549 := @548 @181 +@550 := @547 @549 +@551 := LexLeanPreservation.RunConv +@552 := #13 +@556 := @551 @552 @521 @193 @181 +@558 := @470 @179 @475 +@559 := Exists.{1} +@560 := LexLeanPreservation.Rust.ROut +@561 := @559 @560 +@562 := And +@563 := LexLeanPreservation.Rust.RealizesFn +@567 := @562 (@563 @496 @193 @19) +@568 := LexLeanPreservation.Rust.RCI +@570 := @568 #15 +@571 := LexLeanPreservation.Rust.fnIdent +@572 := @571 @552 +@579 := (hne : @558) -> @561 (fun (ro : @560) => @567 (@570 @572 @544 @19)) +@594 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @494} -> + {F : @467} -> + {o : @469} -> + (hB : @502) -> + (hfn : @520) -> (hwt : @528) -> (hbind : @540) -> (hF : @550) -> (hA : @556) -> @579 +@596 := LexLeanPreservation.Rust.compose @0 +@597 := @495 @0 +@602 := (n : @98) -> @597 @193 @187 @19 @179 +@603 := @512 @125 +@606 := @505 (@603 @179) @519 +@610 := @159 @496 @193 @181 @527 +@611 := @551 @0 +@614 := @611 @521 @193 @181 +@628 := {c : @11} -> + {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @494} -> + {F : @467} -> + {o : @469} -> + (hB : @602) -> + (hfn : @606) -> (hwt : @610) -> (hbind : @540) -> (hF : @550) -> (hA : @614) -> @579 +@629 := @596 @1 +@630 := @597 @1 +@634 := (n : @98) -> @630 @187 @19 @179 +@637 := @167 @193 @181 @527 +@638 := @543 @1 +@641 := @542 (@638 @496) @549 +@642 := @568 @1 +@652 := (hbind : @540) -> + (hF : @641) -> (hA : @614) -> (hne : @558) -> @561 (fun (ro : @560) => @567 (@642 @572 @544 @19)) +@662 := {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @494} -> {F : @467} -> {o : @469} -> (hB : @634) -> (hfn : @606) -> (hwt : @637) -> @652 +@663 := @629 @2 +@665 := @630 @2 @19 +@667 := (n : @98) -> @665 @179 +@668 := @173 @181 +@669 := @668 @527 +@678 := {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @494} -> {F : @467} -> {o : @469} -> (hB : @667) -> (hfn : @606) -> (hwt : @669) -> @652 +@679 := @663 @111 +@681 := (n : @98) -> @665 @111 +@682 := @603 @111 +@683 := @505 @682 +@684 := @683 @519 +@685 := @638 @111 +@686 := @542 @685 +@687 := @686 @549 +@688 := @611 @111 +@690 := @688 @193 @181 +@692 := @642 (@571 @111) +@700 := (hF : @687) -> (hA : @690) -> (hne : @558) -> @561 (fun (ro : @560) => @567 (@692 @544 @19)) +@709 := {fn : @123} -> + {args : @177} -> + {env : @494} -> + {F : @467} -> {o : @469} -> (hB : @681) -> (hfn : @684) -> (hwt : @669) -> (hbind : @540) -> @700 +@710 := @679 @143 +@712 := @683 (@518 @143) +@713 := @526 @143 +@714 := @668 @713 +@716 := @531 (@532 @143) +@728 := {args : @177} -> + {env : @494} -> + {F : @467} -> + {o : @469} -> + (hB : @681) -> (hfn : @712) -> (hwt : @714) -> (hbind : @530 (@716 @179 @114) @539) -> @700 +@729 := @710 @97 +@732 := @381 (@328 (@270 @90)) +@734 := @173 @732 @713 +@736 := @91 (@5 @496) +@741 := @736 (@381 (@91 (@57 @187) @90)) +@745 := @530 (@716 @741 @114) @539 +@747 := @91 (@5 @544) +@749 := @91 (@5 @521) +@754 := @747 (@749 (@91 (@57 @496) @90)) +@756 := @688 @754 @181 +@759 := @91 (@5 #14) +@761 := @91 (@5 @552) +@762 := #12 +@782 := {env : @494} -> + {F : @467} -> + {o : @469} -> + (hB : @681) -> + (hfn : @712) -> + (hwt : @734) -> + (hbind : @745) -> + (hF : @687) -> + (hA : @756) -> + (hne : @558) -> @561 (fun (ro : @560) => @567 (@692 (@759 (@761 (@91 (@57 @762) @90))) @19)) +@783 := @729 @121 +@786 := @328 (@342 (@284 @90)) +@788 := @173 @786 @713 +@802 := @530 (@716 @732 @114) (@538 (@115 (@106 @269) (@115 (@109 @327) (@115 (@112 @380) @114)))) +@807 := @749 (@736 (@91 (@57 @193) @90)) +@809 := @688 @807 @181 +@811 := @91 (@5 @762) +@830 := {F : @467} -> + {o : @469} -> + (hB : @681) -> + (hfn : @712) -> + (hwt : @788) -> + (hbind : @802) -> + (hF : @687) -> + (hA : @809) -> + (hne : @558) -> @561 (fun (ro : @560) => @567 (@692 (@761 (@811 (@91 (@57 @544) @90))) @19)) +@831 := @783 @122 +@832 := @400 @713 +@846 := @530 (@716 @786 @114) (@538 (@115 (@106 @283) (@115 (@109 @341) (@115 (@112 @327) @114)))) +@848 := @686 (@548 @122) +@850 := @688 @741 @181 +@851 := @563 @122 +@872 := {o : @469} -> + (hB : @681) -> + (hfn : @712) -> + (hwt : @832) -> + (hbind : @846) -> + (hF : @848) -> + (hA : @850) -> + (hne : @558) -> + @561 (fun (ro : @560) => @562 (@851 @193 @19) (@692 (@811 (@747 (@91 (@57 @521) @90))) @19)) +@873 := @831 @423 +@874 := @407 @713 +@888 := @530 (@716 @399 @114) (@538 (@115 (@106 @266) (@115 (@109 @324) (@115 (@112 @341) @114)))) +@889 := @688 @732 +@892 := @420 @193 @187 @179 +@893 := @889 @892 +@896 := @420 @496 @193 @187 +@916 := (hB : @681) -> + (hfn : @712) -> + (hwt : @874) -> + (hbind : @888) -> + (hF : @848) -> + (hA : @893) -> + (hne : @470 @896 @475) -> + @561 (fun (ro : @560) => @562 (@851 (@420 @544 @521 @496) @19) (@692 @754 @19)) +@917 := @873 @147 +@918 := @414 @713 +@932 := @530 (@716 @406 @114) (@538 (@115 (@106 @280) (@115 (@109 @338) (@115 (@112 @324) @114)))) +@933 := @688 @786 +@936 := @420 @187 @179 @181 +@956 := (hfn : @712) -> + (hwt : @918) -> + (hbind : @932) -> + (hF : @848) -> + (hA : @933 @936) -> + (hne : @470 @892 @475) -> + @561 (fun (ro : @560) => @562 (@851 (@420 @521 @496 @193) @19) (@692 @807 @19)) +@957 := Eq.refl.{1} +@960 := @917 (@957 @504 @682) +@961 := @418 @713 +@975 := @530 (@716 @413 @114) (@538 (@115 (@106 @295) (@115 (@109 @6) (@115 (@112 @338) @114)))) +@976 := @688 @399 +@979 := @420 @179 @181 @183 +@995 := (hwt : @961) -> + (hbind : @975) -> + (hF : @848) -> + (hA : @976 @979) -> + (hne : @470 @936 @475) -> @561 (fun (ro : @560) => @562 (@851 @896 @19) (@692 @741 @19)) +@996 := @960 @417 +@998 := @716 @97 @114 +@1001 := @530 @998 (@538 @121) +@1002 := @688 @406 +@1005 := @420 @181 @183 @4 +@1020 := (hbind : @1001) -> + (hF : @848) -> + (hA : @1002 @1005) -> + (hne : @470 @979 @475) -> @561 (fun (ro : @560) => @562 (@851 @892 @19) (@692 @732 @19)) +@1023 := @996 (@957 @529 @998) +@1024 := @688 @413 +@1027 := @420 @183 @4 @15 +@1041 := (hF : @848) -> + (hA : @1024 @1027) -> + (hne : @470 @1005 @475) -> @561 (fun (ro : @560) => @562 (@851 @936 @19) (@692 @786 @19)) +@1044 := @1023 (@957 @541 @685) +@1058 := (hA : @688 @97 @423) -> + (hne : @470 @1027 @475) -> @561 (fun (ro : @560) => @562 (@851 @979 @19) (@692 @399 @19)) +@1059 := @1044 @466 +@1070 := (hne : @470 @423 @475) -> @561 (fun (ro : @560) => @562 (@851 @1005 @19) (@692 @406 @19)) +@1071 := @1059 @489 +@1077 := @562 (@851 @1027 @19) (@692 @413 @19) +@1079 := @561 (fun (ro : @560) => @1077) +@1081 := @561 (fun (__e_ro : @560) => @1077) +@1082 := LexLeanPreservation.Rust.RepresentableL +@1083 := @5 @17 +@1085 := @91 @61 @90 +@1089 := @1082 (@94 (@91 @1083 @1085)) +@1090 := (__e_hrep : @1089) -> @1081 +@1091 := fun (__e_hrep : @1089) => @1071 +@1092 := (c : @56) -> @1090 +@1093 := fun (c : @56) => @1091 +@1094 := (b : @3) -> @1092 +@1095 := fun (b : @3) => @1093 +@1096 := (a : @3) -> @1094 +@1097 := fun (a : @3) => @1095 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustCore.lean deleted file mode 100644 index 6c6be2423..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : UInt16) (b : UInt16) (s : UInt32) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.u16 a), (_root_.LexLeanTarget.TargetSyntax.Value.u16 b), (_root_.LexLeanTarget.TargetSyntax.Value.u32 s)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.denote a b s) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.u16 a), (_root_.LexLeanTarget.TargetSyntax.Value.u16 b), (_root_.LexLeanTarget.TargetSyntax.Value.u32 s)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u16 a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u16 b) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u32 s) _root_.LexLeanPreservation.Rust.wtl_nil))) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.root a b s) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustCore.lex.tex new file mode 100644 index 000000000..c492436ed --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustCore.lex.tex @@ -0,0 +1,546 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore.root : @1100 := @1101 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore.flags +@3 := UInt16 +@4 := #3 +@5 := LexLeanTarget.TargetSyntax.Value.u16 +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.fixed +@9 := @7 LexLeanTarget.TargetSyntax.IntKind.u16 +@10 := LexLeanTarget.TargetSyntax.Program +@11 := LexLeanPreservation.Rust.RCrate +@12 := LexLeanPreservation.Rust.Flags +@13 := LexLeanPreservation.Rust.WT +@14 := @13 @4 +@15 := #2 +@16 := @14 @15 +@17 := #1 +@18 := @16 @17 +@19 := #0 +@20 := @5 @19 +@26 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @3) -> @18 @20 @9 +@28 := LexLeanPreservation.Rust.wt_u16 @0 +@29 := @13 @0 +@31 := @29 @15 @17 +@36 := {c : @11} -> {A : @12} -> (x : @3) -> @31 @20 @9 +@37 := @28 @1 +@38 := @29 @1 +@39 := @38 @17 +@43 := {A : @12} -> (x : @3) -> @39 @20 @9 +@44 := @37 @2 +@45 := @38 @2 +@48 := (x : @3) -> @45 @20 @9 +@49 := @44 @4 +@51 := @45 @6 @9 +@52 := @5 @15 +@53 := @44 @15 +@55 := @45 @52 @9 +@56 := UInt32 +@57 := LexLeanTarget.TargetSyntax.Value.u32 +@58 := @57 @17 +@60 := @7 LexLeanTarget.TargetSyntax.IntKind.u32 +@61 := @57 @19 +@67 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @56) -> @18 @61 @60 +@69 := LexLeanPreservation.Rust.wt_u32 @0 +@74 := {c : @11} -> {A : @12} -> (x : @56) -> @31 @61 @60 +@75 := @69 @1 +@79 := {A : @12} -> (x : @56) -> @39 @61 @60 +@80 := @75 @2 +@83 := (x : @56) -> @45 @61 @60 +@84 := @80 @17 +@86 := @45 @58 @60 +@87 := LexLeanTarget.TargetSyntax.Value +@88 := List.nil.{0} +@89 := List.cons.{0} +@90 := @88 @87 +@91 := @89 @87 +@93 := @91 @58 @90 +@94 := @91 @52 +@95 := @94 @93 +@96 := @91 @6 +@97 := @96 @95 +@98 := Nat +@99 := Prod.{0, 0} +@101 := @99 @98 @87 +@102 := 2 +@105 := Prod.mk.{0, 0} @98 @87 +@106 := @105 @102 +@107 := @106 @58 +@109 := @105 1 +@110 := @109 @52 +@111 := 0 +@112 := @105 @111 +@113 := @112 @6 +@114 := @88 @101 +@115 := @89 @101 +@117 := @115 @113 @114 +@119 := @115 @110 @117 +@121 := @115 @107 @119 +@122 := Bool.false +@123 := LexLeanTarget.TargetSyntax.Function +@124 := LexLeanTarget.TargetSyntax.Program.functions +@125 := @124 @0 +@126 := LexLeanTarget.TargetSyntax.Ty +@127 := @88 @98 +@128 := @88 @126 +@129 := LexLeanTarget.TargetSyntax.Ty.unit +@130 := LexLeanTarget.TargetSyntax.Value.unit +@133 := LexLeanTarget.TargetSyntax.Expr.value @129 @130 +@138 := LexLeanTarget.TargetSyntax.Function.mk @127 @128 @129 @133 +@143 := List.getD.{0} @123 @125 @111 @138 +@147 := fun (__e_n : @98) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore.root @19 @111 +@148 := LexLeanPreservation.Rust.WTL +@156 := {p : @10} -> {c : @11} -> {A : @12} -> @148 @15 @17 @19 @90 @128 +@158 := LexLeanPreservation.Rust.wtl_nil @0 +@159 := @148 @0 +@165 := {c : @11} -> {A : @12} -> @159 @17 @19 @90 @128 +@166 := @158 @1 +@167 := @159 @1 +@171 := {A : @12} -> @167 @19 @90 @128 +@172 := @166 @2 +@173 := @167 @2 +@174 := @173 @90 +@175 := @174 @128 +@176 := List.{0} +@177 := @176 @87 +@178 := @176 @126 +@179 := #6 +@180 := @13 @179 +@181 := #5 +@182 := @180 @181 +@183 := #4 +@186 := @182 @183 @4 @15 +@187 := #7 +@192 := @148 @187 @179 @181 @15 @17 +@193 := #8 +@196 := @148 @193 @187 @179 +@198 := @91 @181 @4 +@199 := @196 @198 +@200 := @89 @126 +@202 := @200 @183 @15 +@212 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {v : @87} -> {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @186) -> (hs : @192) -> @199 @202 +@214 := LexLeanPreservation.Rust.wtl_cons @0 +@234 := {c : @11} -> + {A : @12} -> + {v : @87} -> + {t : @126} -> + {vs : @177} -> + {ts : @178} -> + (h : @29 @181 @183 @4 @15) -> (hs : @159 @179 @181 @15 @17) -> @159 @187 @179 @198 @202 +@235 := @214 @1 +@251 := {A : @12} -> + {v : @87} -> + {t : @126} -> + {vs : @177} -> + {ts : @178} -> (h : @38 @183 @4 @15) -> (hs : @167 @181 @15 @17) -> @167 @179 @198 @202 +@252 := @235 @2 +@254 := @45 @4 @15 +@256 := @173 @15 @17 +@264 := {v : @87} -> + {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @254) -> (hs : @256) -> @173 @198 @202 +@265 := @252 @58 +@266 := @57 @183 +@268 := @45 @266 @15 +@269 := @57 @179 +@270 := @91 @269 +@278 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @268) -> (hs : @256) -> @173 (@270 @4) @202 +@279 := @265 @60 +@280 := @57 @4 +@282 := @45 @280 @60 +@283 := @57 @181 +@284 := @91 @283 +@286 := @173 (@284 @4) +@287 := @200 @60 +@288 := @287 @15 +@293 := {vs : @177} -> {ts : @178} -> (h : @282) -> (hs : @256) -> @286 @288 +@294 := @279 @90 +@295 := @57 @15 +@297 := @45 @295 @60 +@298 := @174 @17 +@300 := @91 @266 @90 +@305 := {ts : @178} -> (h : @297) -> (hs : @298) -> @173 @300 @288 +@306 := @294 @128 +@308 := @91 @280 @90 +@309 := @173 @308 +@310 := @287 @128 +@313 := (h : @86) -> (hs : @175) -> @309 @310 +@314 := @306 @84 +@316 := @91 @295 @90 +@318 := @173 @316 @310 +@319 := (hs : @175) -> @318 +@320 := @314 @172 +@322 := @173 @93 @310 +@323 := @252 @52 +@324 := @5 @181 +@325 := @45 @324 +@326 := @325 @15 +@327 := @5 @187 +@328 := @91 @327 +@330 := @173 (@328 @4) +@336 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @326) -> (hs : @256) -> @330 @202 +@337 := @323 @9 +@338 := @5 @183 +@340 := @45 @338 @9 +@341 := @5 @179 +@342 := @91 @341 +@344 := @173 (@342 @4) +@345 := @200 @9 +@346 := @345 @15 +@351 := {vs : @177} -> {ts : @178} -> (h : @340) -> (hs : @256) -> @344 @346 +@352 := @337 @93 +@353 := @309 @17 +@354 := @91 @324 +@355 := @354 @300 +@360 := {ts : @178} -> (h : @51) -> (hs : @353) -> @173 @355 @346 +@361 := @352 @310 +@362 := @91 @338 +@363 := @362 @308 +@364 := @173 @363 +@365 := @345 @310 +@368 := (h : @55) -> (hs : @318) -> @364 @365 +@369 := @361 @53 +@370 := @96 @316 +@372 := @173 @370 @365 +@373 := (hs : @322) -> @372 +@374 := @369 @320 +@376 := @173 @95 @365 +@377 := @252 @6 +@379 := @45 @341 @15 +@380 := @5 @193 +@381 := @91 @380 +@389 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @379) -> (hs : @256) -> @173 (@381 @4) @202 +@390 := @377 @9 +@396 := {vs : @177} -> {ts : @178} -> (h : @325 @9) -> (hs : @256) -> @330 @346 +@397 := @390 @95 +@398 := @364 @17 +@399 := @342 @355 +@400 := @173 @399 +@404 := {ts : @178} -> (h : @340) -> (hs : @398) -> @400 @346 +@405 := @397 @365 +@406 := @354 @363 +@407 := @173 @406 +@408 := @345 @365 +@411 := (h : @51) -> (hs : @372) -> @407 @408 +@412 := @405 @49 +@413 := @362 @370 +@414 := @173 @413 +@416 := (hs : @376) -> @414 @408 +@417 := @412 @374 +@418 := @173 @97 +@419 := @418 @408 +@420 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.denote +@423 := @420 @4 @15 @17 +@424 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.__fits_0 +@427 := @424 @4 @15 @17 +@431 := Coverage.Prims.bits @4 @15 @17 +@432 := Option.{0} +@433 := @432 @3 +@434 := Bool +@435 := @99 @433 +@436 := @435 @434 +@437 := @435 @436 +@438 := @99 @3 +@439 := @438 @437 +@440 := @438 @439 +@441 := @438 @440 +@444 := LexLeanPreservation.encOption @3 @5 +@445 := LexLeanTarget.TargetSyntax.Value.bool +@446 := LexLeanPreservation.encPair +@447 := @446 @433 +@450 := @447 @434 @444 @445 +@453 := @447 @436 @444 @450 +@454 := @446 @3 +@457 := @454 @437 @5 @453 +@460 := @454 @439 @5 @457 +@463 := @454 @440 @5 @460 +@467 := @454 @441 @5 @463 @431 +@471 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.root @4 @15 @17 +@472 := Ne.{1} +@473 := LexLeanPreservation.Obs +@474 := @472 @473 +@475 := LexLeanPreservation.Rel +@478 := @474 (@475 @17 @19) +@479 := LexLeanPreservation.Obs.stuck +@482 := (f : @434) -> (v : @87) -> @478 @479 +@484 := LexLeanPreservation.Rust.rel_ne_stuck @427 +@492 := (v : @87) -> @474 (@475 (@424 @183 @4 @15) @19) @479 +@493 := @484 @467 +@497 := @474 (@475 @427 @467) @479 +@498 := @176 @101 +@499 := LexLeanPreservation.Rust.FunSem +@500 := #9 +@506 := (n : @98) -> @499 @500 @193 @187 @19 @179 +@507 := Eq.{1} +@508 := @432 @123 +@509 := @507 @508 +@516 := LexLeanRuntime.index (@176 @123) @123 (LexLeanRuntime.instIndexableList @123) +@520 := @509 (@516 (@124 @500) @179) +@521 := Option.some.{0} +@522 := @521 @123 +@523 := @522 @181 +@524 := @520 @523 +@525 := #10 +@529 := @148 @525 @500 @193 @181 +@530 := LexLeanTarget.TargetSyntax.Function.types +@531 := @530 @179 +@532 := @529 @531 +@533 := @432 @498 +@534 := @507 @533 +@535 := LexLeanTarget.TargetSemantics.bindAll +@536 := LexLeanTarget.TargetSyntax.Function.parameters +@541 := @534 (@535 (@536 @187) @179 @114) +@542 := @521 @498 +@543 := @542 @181 +@544 := @541 @543 +@545 := @432 @434 +@546 := @507 @545 +@547 := LexLeanPreservation.Rust.fnFallible +@548 := #11 +@551 := @546 (@547 @548 @500) +@552 := @521 @434 +@553 := @552 @181 +@554 := @551 @553 +@555 := LexLeanPreservation.RunConv +@556 := #13 +@560 := @555 @556 @525 @193 @181 +@562 := @474 @179 @479 +@563 := Exists.{1} +@564 := LexLeanPreservation.Rust.ROut +@565 := @563 @564 +@566 := And +@567 := LexLeanPreservation.Rust.RealizesFn +@571 := @566 (@567 @500 @193 @19) +@572 := LexLeanPreservation.Rust.RCI +@574 := @572 #15 +@575 := LexLeanPreservation.Rust.fnIdent +@576 := @575 @556 +@583 := (hne : @562) -> @565 (fun (ro : @564) => @571 (@574 @576 @548 @19)) +@598 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @498} -> + {F : @434} -> + {o : @473} -> + (hB : @506) -> + (hfn : @524) -> (hwt : @532) -> (hbind : @544) -> (hF : @554) -> (hA : @560) -> @583 +@600 := LexLeanPreservation.Rust.compose @0 +@601 := @499 @0 +@606 := (n : @98) -> @601 @193 @187 @19 @179 +@607 := @516 @125 +@610 := @509 (@607 @179) @523 +@614 := @159 @500 @193 @181 @531 +@615 := @555 @0 +@618 := @615 @525 @193 @181 +@632 := {c : @11} -> + {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @498} -> + {F : @434} -> + {o : @473} -> + (hB : @606) -> + (hfn : @610) -> (hwt : @614) -> (hbind : @544) -> (hF : @554) -> (hA : @618) -> @583 +@633 := @600 @1 +@634 := @601 @1 +@638 := (n : @98) -> @634 @187 @19 @179 +@641 := @167 @193 @181 @531 +@642 := @547 @1 +@645 := @546 (@642 @500) @553 +@646 := @572 @1 +@656 := (hbind : @544) -> + (hF : @645) -> (hA : @618) -> (hne : @562) -> @565 (fun (ro : @564) => @571 (@646 @576 @548 @19)) +@666 := {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @498} -> {F : @434} -> {o : @473} -> (hB : @638) -> (hfn : @610) -> (hwt : @641) -> @656 +@667 := @633 @2 +@669 := @634 @2 @19 +@671 := (n : @98) -> @669 @179 +@672 := @173 @181 +@673 := @672 @531 +@682 := {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @498} -> {F : @434} -> {o : @473} -> (hB : @671) -> (hfn : @610) -> (hwt : @673) -> @656 +@683 := @667 @111 +@685 := (n : @98) -> @669 @111 +@686 := @607 @111 +@687 := @509 @686 +@688 := @687 @523 +@689 := @642 @111 +@690 := @546 @689 +@691 := @690 @553 +@692 := @615 @111 +@694 := @692 @193 @181 +@696 := @646 (@575 @111) +@704 := (hF : @691) -> (hA : @694) -> (hne : @562) -> @565 (fun (ro : @564) => @571 (@696 @548 @19)) +@713 := {fn : @123} -> + {args : @177} -> + {env : @498} -> + {F : @434} -> {o : @473} -> (hB : @685) -> (hfn : @688) -> (hwt : @673) -> (hbind : @544) -> @704 +@714 := @683 @143 +@716 := @687 (@522 @143) +@717 := @530 @143 +@718 := @672 @717 +@720 := @535 (@536 @143) +@732 := {args : @177} -> + {env : @498} -> + {F : @434} -> + {o : @473} -> + (hB : @685) -> (hfn : @716) -> (hwt : @718) -> (hbind : @534 (@720 @179 @114) @543) -> @704 +@733 := @714 @97 +@736 := @381 (@328 (@270 @90)) +@738 := @173 @736 @717 +@740 := @91 (@5 @500) +@745 := @740 (@381 (@91 (@57 @187) @90)) +@749 := @534 (@720 @745 @114) @543 +@751 := @91 (@5 @548) +@753 := @91 (@5 @525) +@758 := @751 (@753 (@91 (@57 @500) @90)) +@760 := @692 @758 @181 +@763 := @91 (@5 #14) +@765 := @91 (@5 @556) +@766 := #12 +@786 := {env : @498} -> + {F : @434} -> + {o : @473} -> + (hB : @685) -> + (hfn : @716) -> + (hwt : @738) -> + (hbind : @749) -> + (hF : @691) -> + (hA : @760) -> + (hne : @562) -> @565 (fun (ro : @564) => @571 (@696 (@763 (@765 (@91 (@57 @766) @90))) @19)) +@787 := @733 @121 +@790 := @328 (@342 (@284 @90)) +@792 := @173 @790 @717 +@806 := @534 (@720 @736 @114) (@542 (@115 (@106 @269) (@115 (@109 @327) (@115 (@112 @380) @114)))) +@811 := @753 (@740 (@91 (@57 @193) @90)) +@813 := @692 @811 @181 +@815 := @91 (@5 @766) +@834 := {F : @434} -> + {o : @473} -> + (hB : @685) -> + (hfn : @716) -> + (hwt : @792) -> + (hbind : @806) -> + (hF : @691) -> + (hA : @813) -> + (hne : @562) -> @565 (fun (ro : @564) => @571 (@696 (@765 (@815 (@91 (@57 @548) @90))) @19)) +@835 := @787 @122 +@836 := @400 @717 +@850 := @534 (@720 @790 @114) (@542 (@115 (@106 @283) (@115 (@109 @341) (@115 (@112 @327) @114)))) +@852 := @690 (@552 @122) +@854 := @692 @745 @181 +@855 := @567 @122 +@876 := {o : @473} -> + (hB : @685) -> + (hfn : @716) -> + (hwt : @836) -> + (hbind : @850) -> + (hF : @852) -> + (hA : @854) -> + (hne : @562) -> + @565 (fun (ro : @564) => @566 (@855 @193 @19) (@696 (@815 (@751 (@91 (@57 @525) @90))) @19)) +@877 := @835 @423 +@878 := @407 @717 +@892 := @534 (@720 @399 @114) (@542 (@115 (@106 @266) (@115 (@109 @324) (@115 (@112 @341) @114)))) +@893 := @692 @736 +@896 := @420 @193 @187 @179 +@897 := @893 @896 +@900 := @420 @500 @193 @187 +@920 := (hB : @685) -> + (hfn : @716) -> + (hwt : @878) -> + (hbind : @892) -> + (hF : @852) -> + (hA : @897) -> + (hne : @474 @900 @479) -> + @565 (fun (ro : @564) => @566 (@855 (@420 @548 @525 @500) @19) (@696 @758 @19)) +@921 := @877 @147 +@922 := @414 @717 +@936 := @534 (@720 @406 @114) (@542 (@115 (@106 @280) (@115 (@109 @338) (@115 (@112 @324) @114)))) +@937 := @692 @790 +@940 := @420 @187 @179 @181 +@960 := (hfn : @716) -> + (hwt : @922) -> + (hbind : @936) -> + (hF : @852) -> + (hA : @937 @940) -> + (hne : @474 @896 @479) -> + @565 (fun (ro : @564) => @566 (@855 (@420 @525 @500 @193) @19) (@696 @811 @19)) +@961 := Eq.refl.{1} +@964 := @921 (@961 @508 @686) +@965 := @418 @717 +@979 := @534 (@720 @413 @114) (@542 (@115 (@106 @295) (@115 (@109 @6) (@115 (@112 @338) @114)))) +@980 := @692 @399 +@983 := @420 @179 @181 @183 +@999 := (hwt : @965) -> + (hbind : @979) -> + (hF : @852) -> + (hA : @980 @983) -> + (hne : @474 @940 @479) -> @565 (fun (ro : @564) => @566 (@855 @900 @19) (@696 @745 @19)) +@1000 := @964 @417 +@1002 := @720 @97 @114 +@1005 := @534 @1002 (@542 @121) +@1006 := @692 @406 +@1009 := @420 @181 @183 @4 +@1024 := (hbind : @1005) -> + (hF : @852) -> + (hA : @1006 @1009) -> + (hne : @474 @983 @479) -> @565 (fun (ro : @564) => @566 (@855 @896 @19) (@696 @736 @19)) +@1027 := @1000 (@961 @533 @1002) +@1028 := @692 @413 +@1031 := @420 @183 @4 @15 +@1045 := (hF : @852) -> + (hA : @1028 @1031) -> + (hne : @474 @1009 @479) -> @565 (fun (ro : @564) => @566 (@855 @940 @19) (@696 @790 @19)) +@1048 := @1027 (@961 @545 @689) +@1062 := (hA : @692 @97 @423) -> + (hne : @474 @1031 @479) -> @565 (fun (ro : @564) => @566 (@855 @983 @19) (@696 @399 @19)) +@1063 := @1048 @471 +@1074 := (hne : @474 @423 @479) -> @565 (fun (ro : @564) => @566 (@855 @1009 @19) (@696 @406 @19)) +@1075 := @1063 @493 +@1081 := @566 (@855 @1031 @19) (@696 @413 @19) +@1083 := @565 (fun (ro : @564) => @1081) +@1085 := @565 (fun (__e_ro : @564) => @1081) +@1086 := LexLeanPreservation.Rust.RepresentableL +@1087 := @5 @17 +@1089 := @91 @61 @90 +@1093 := @1086 (@94 (@91 @1087 @1089)) +@1094 := (__e_hrep : @1093) -> @1085 +@1095 := fun (__e_hrep : @1093) => @1075 +@1096 := (s : @56) -> @1094 +@1097 := fun (s : @56) => @1095 +@1098 := (b : @3) -> @1096 +@1099 := fun (b : @3) => @1097 +@1100 := (a : @3) -> @1098 +@1101 := fun (a : @3) => @1099 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustStd.lean deleted file mode 100644 index 679585f7b..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : UInt16) (b : UInt16) (s : UInt32) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.u16 a), (_root_.LexLeanTarget.TargetSyntax.Value.u16 b), (_root_.LexLeanTarget.TargetSyntax.Value.u32 s)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.denote a b s) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.u16 a), (_root_.LexLeanTarget.TargetSyntax.Value.u16 b), (_root_.LexLeanTarget.TargetSyntax.Value.u32 s)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u16 a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u16 b) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u32 s) _root_.LexLeanPreservation.Rust.wtl_nil))) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.root a b s) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustStd.lex.tex new file mode 100644 index 000000000..ac8ee74dc --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustStd.lex.tex @@ -0,0 +1,546 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd.root : @1100 := @1101 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd.flags +@3 := UInt16 +@4 := #3 +@5 := LexLeanTarget.TargetSyntax.Value.u16 +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.fixed +@9 := @7 LexLeanTarget.TargetSyntax.IntKind.u16 +@10 := LexLeanTarget.TargetSyntax.Program +@11 := LexLeanPreservation.Rust.RCrate +@12 := LexLeanPreservation.Rust.Flags +@13 := LexLeanPreservation.Rust.WT +@14 := @13 @4 +@15 := #2 +@16 := @14 @15 +@17 := #1 +@18 := @16 @17 +@19 := #0 +@20 := @5 @19 +@26 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @3) -> @18 @20 @9 +@28 := LexLeanPreservation.Rust.wt_u16 @0 +@29 := @13 @0 +@31 := @29 @15 @17 +@36 := {c : @11} -> {A : @12} -> (x : @3) -> @31 @20 @9 +@37 := @28 @1 +@38 := @29 @1 +@39 := @38 @17 +@43 := {A : @12} -> (x : @3) -> @39 @20 @9 +@44 := @37 @2 +@45 := @38 @2 +@48 := (x : @3) -> @45 @20 @9 +@49 := @44 @4 +@51 := @45 @6 @9 +@52 := @5 @15 +@53 := @44 @15 +@55 := @45 @52 @9 +@56 := UInt32 +@57 := LexLeanTarget.TargetSyntax.Value.u32 +@58 := @57 @17 +@60 := @7 LexLeanTarget.TargetSyntax.IntKind.u32 +@61 := @57 @19 +@67 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @56) -> @18 @61 @60 +@69 := LexLeanPreservation.Rust.wt_u32 @0 +@74 := {c : @11} -> {A : @12} -> (x : @56) -> @31 @61 @60 +@75 := @69 @1 +@79 := {A : @12} -> (x : @56) -> @39 @61 @60 +@80 := @75 @2 +@83 := (x : @56) -> @45 @61 @60 +@84 := @80 @17 +@86 := @45 @58 @60 +@87 := LexLeanTarget.TargetSyntax.Value +@88 := List.nil.{0} +@89 := List.cons.{0} +@90 := @88 @87 +@91 := @89 @87 +@93 := @91 @58 @90 +@94 := @91 @52 +@95 := @94 @93 +@96 := @91 @6 +@97 := @96 @95 +@98 := Nat +@99 := Prod.{0, 0} +@101 := @99 @98 @87 +@102 := 2 +@105 := Prod.mk.{0, 0} @98 @87 +@106 := @105 @102 +@107 := @106 @58 +@109 := @105 1 +@110 := @109 @52 +@111 := 0 +@112 := @105 @111 +@113 := @112 @6 +@114 := @88 @101 +@115 := @89 @101 +@117 := @115 @113 @114 +@119 := @115 @110 @117 +@121 := @115 @107 @119 +@122 := Bool.false +@123 := LexLeanTarget.TargetSyntax.Function +@124 := LexLeanTarget.TargetSyntax.Program.functions +@125 := @124 @0 +@126 := LexLeanTarget.TargetSyntax.Ty +@127 := @88 @98 +@128 := @88 @126 +@129 := LexLeanTarget.TargetSyntax.Ty.unit +@130 := LexLeanTarget.TargetSyntax.Value.unit +@133 := LexLeanTarget.TargetSyntax.Expr.value @129 @130 +@138 := LexLeanTarget.TargetSyntax.Function.mk @127 @128 @129 @133 +@143 := List.getD.{0} @123 @125 @111 @138 +@147 := fun (__e_n : @98) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd.root @19 @111 +@148 := LexLeanPreservation.Rust.WTL +@156 := {p : @10} -> {c : @11} -> {A : @12} -> @148 @15 @17 @19 @90 @128 +@158 := LexLeanPreservation.Rust.wtl_nil @0 +@159 := @148 @0 +@165 := {c : @11} -> {A : @12} -> @159 @17 @19 @90 @128 +@166 := @158 @1 +@167 := @159 @1 +@171 := {A : @12} -> @167 @19 @90 @128 +@172 := @166 @2 +@173 := @167 @2 +@174 := @173 @90 +@175 := @174 @128 +@176 := List.{0} +@177 := @176 @87 +@178 := @176 @126 +@179 := #6 +@180 := @13 @179 +@181 := #5 +@182 := @180 @181 +@183 := #4 +@186 := @182 @183 @4 @15 +@187 := #7 +@192 := @148 @187 @179 @181 @15 @17 +@193 := #8 +@196 := @148 @193 @187 @179 +@198 := @91 @181 @4 +@199 := @196 @198 +@200 := @89 @126 +@202 := @200 @183 @15 +@212 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {v : @87} -> {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @186) -> (hs : @192) -> @199 @202 +@214 := LexLeanPreservation.Rust.wtl_cons @0 +@234 := {c : @11} -> + {A : @12} -> + {v : @87} -> + {t : @126} -> + {vs : @177} -> + {ts : @178} -> + (h : @29 @181 @183 @4 @15) -> (hs : @159 @179 @181 @15 @17) -> @159 @187 @179 @198 @202 +@235 := @214 @1 +@251 := {A : @12} -> + {v : @87} -> + {t : @126} -> + {vs : @177} -> + {ts : @178} -> (h : @38 @183 @4 @15) -> (hs : @167 @181 @15 @17) -> @167 @179 @198 @202 +@252 := @235 @2 +@254 := @45 @4 @15 +@256 := @173 @15 @17 +@264 := {v : @87} -> + {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @254) -> (hs : @256) -> @173 @198 @202 +@265 := @252 @58 +@266 := @57 @183 +@268 := @45 @266 @15 +@269 := @57 @179 +@270 := @91 @269 +@278 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @268) -> (hs : @256) -> @173 (@270 @4) @202 +@279 := @265 @60 +@280 := @57 @4 +@282 := @45 @280 @60 +@283 := @57 @181 +@284 := @91 @283 +@286 := @173 (@284 @4) +@287 := @200 @60 +@288 := @287 @15 +@293 := {vs : @177} -> {ts : @178} -> (h : @282) -> (hs : @256) -> @286 @288 +@294 := @279 @90 +@295 := @57 @15 +@297 := @45 @295 @60 +@298 := @174 @17 +@300 := @91 @266 @90 +@305 := {ts : @178} -> (h : @297) -> (hs : @298) -> @173 @300 @288 +@306 := @294 @128 +@308 := @91 @280 @90 +@309 := @173 @308 +@310 := @287 @128 +@313 := (h : @86) -> (hs : @175) -> @309 @310 +@314 := @306 @84 +@316 := @91 @295 @90 +@318 := @173 @316 @310 +@319 := (hs : @175) -> @318 +@320 := @314 @172 +@322 := @173 @93 @310 +@323 := @252 @52 +@324 := @5 @181 +@325 := @45 @324 +@326 := @325 @15 +@327 := @5 @187 +@328 := @91 @327 +@330 := @173 (@328 @4) +@336 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @326) -> (hs : @256) -> @330 @202 +@337 := @323 @9 +@338 := @5 @183 +@340 := @45 @338 @9 +@341 := @5 @179 +@342 := @91 @341 +@344 := @173 (@342 @4) +@345 := @200 @9 +@346 := @345 @15 +@351 := {vs : @177} -> {ts : @178} -> (h : @340) -> (hs : @256) -> @344 @346 +@352 := @337 @93 +@353 := @309 @17 +@354 := @91 @324 +@355 := @354 @300 +@360 := {ts : @178} -> (h : @51) -> (hs : @353) -> @173 @355 @346 +@361 := @352 @310 +@362 := @91 @338 +@363 := @362 @308 +@364 := @173 @363 +@365 := @345 @310 +@368 := (h : @55) -> (hs : @318) -> @364 @365 +@369 := @361 @53 +@370 := @96 @316 +@372 := @173 @370 @365 +@373 := (hs : @322) -> @372 +@374 := @369 @320 +@376 := @173 @95 @365 +@377 := @252 @6 +@379 := @45 @341 @15 +@380 := @5 @193 +@381 := @91 @380 +@389 := {t : @126} -> {vs : @177} -> {ts : @178} -> (h : @379) -> (hs : @256) -> @173 (@381 @4) @202 +@390 := @377 @9 +@396 := {vs : @177} -> {ts : @178} -> (h : @325 @9) -> (hs : @256) -> @330 @346 +@397 := @390 @95 +@398 := @364 @17 +@399 := @342 @355 +@400 := @173 @399 +@404 := {ts : @178} -> (h : @340) -> (hs : @398) -> @400 @346 +@405 := @397 @365 +@406 := @354 @363 +@407 := @173 @406 +@408 := @345 @365 +@411 := (h : @51) -> (hs : @372) -> @407 @408 +@412 := @405 @49 +@413 := @362 @370 +@414 := @173 @413 +@416 := (hs : @376) -> @414 @408 +@417 := @412 @374 +@418 := @173 @97 +@419 := @418 @408 +@420 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.denote +@423 := @420 @4 @15 @17 +@424 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.__fits_0 +@427 := @424 @4 @15 @17 +@431 := Coverage.Prims.bits @4 @15 @17 +@432 := Option.{0} +@433 := @432 @3 +@434 := Bool +@435 := @99 @433 +@436 := @435 @434 +@437 := @435 @436 +@438 := @99 @3 +@439 := @438 @437 +@440 := @438 @439 +@441 := @438 @440 +@444 := LexLeanPreservation.encOption @3 @5 +@445 := LexLeanTarget.TargetSyntax.Value.bool +@446 := LexLeanPreservation.encPair +@447 := @446 @433 +@450 := @447 @434 @444 @445 +@453 := @447 @436 @444 @450 +@454 := @446 @3 +@457 := @454 @437 @5 @453 +@460 := @454 @439 @5 @457 +@463 := @454 @440 @5 @460 +@467 := @454 @441 @5 @463 @431 +@471 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.root @4 @15 @17 +@472 := Ne.{1} +@473 := LexLeanPreservation.Obs +@474 := @472 @473 +@475 := LexLeanPreservation.Rel +@478 := @474 (@475 @17 @19) +@479 := LexLeanPreservation.Obs.stuck +@482 := (f : @434) -> (v : @87) -> @478 @479 +@484 := LexLeanPreservation.Rust.rel_ne_stuck @427 +@492 := (v : @87) -> @474 (@475 (@424 @183 @4 @15) @19) @479 +@493 := @484 @467 +@497 := @474 (@475 @427 @467) @479 +@498 := @176 @101 +@499 := LexLeanPreservation.Rust.FunSem +@500 := #9 +@506 := (n : @98) -> @499 @500 @193 @187 @19 @179 +@507 := Eq.{1} +@508 := @432 @123 +@509 := @507 @508 +@516 := LexLeanRuntime.index (@176 @123) @123 (LexLeanRuntime.instIndexableList @123) +@520 := @509 (@516 (@124 @500) @179) +@521 := Option.some.{0} +@522 := @521 @123 +@523 := @522 @181 +@524 := @520 @523 +@525 := #10 +@529 := @148 @525 @500 @193 @181 +@530 := LexLeanTarget.TargetSyntax.Function.types +@531 := @530 @179 +@532 := @529 @531 +@533 := @432 @498 +@534 := @507 @533 +@535 := LexLeanTarget.TargetSemantics.bindAll +@536 := LexLeanTarget.TargetSyntax.Function.parameters +@541 := @534 (@535 (@536 @187) @179 @114) +@542 := @521 @498 +@543 := @542 @181 +@544 := @541 @543 +@545 := @432 @434 +@546 := @507 @545 +@547 := LexLeanPreservation.Rust.fnFallible +@548 := #11 +@551 := @546 (@547 @548 @500) +@552 := @521 @434 +@553 := @552 @181 +@554 := @551 @553 +@555 := LexLeanPreservation.RunConv +@556 := #13 +@560 := @555 @556 @525 @193 @181 +@562 := @474 @179 @479 +@563 := Exists.{1} +@564 := LexLeanPreservation.Rust.ROut +@565 := @563 @564 +@566 := And +@567 := LexLeanPreservation.Rust.RealizesFn +@571 := @566 (@567 @500 @193 @19) +@572 := LexLeanPreservation.Rust.RCI +@574 := @572 #15 +@575 := LexLeanPreservation.Rust.fnIdent +@576 := @575 @556 +@583 := (hne : @562) -> @565 (fun (ro : @564) => @571 (@574 @576 @548 @19)) +@598 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @498} -> + {F : @434} -> + {o : @473} -> + (hB : @506) -> + (hfn : @524) -> (hwt : @532) -> (hbind : @544) -> (hF : @554) -> (hA : @560) -> @583 +@600 := LexLeanPreservation.Rust.compose @0 +@601 := @499 @0 +@606 := (n : @98) -> @601 @193 @187 @19 @179 +@607 := @516 @125 +@610 := @509 (@607 @179) @523 +@614 := @159 @500 @193 @181 @531 +@615 := @555 @0 +@618 := @615 @525 @193 @181 +@632 := {c : @11} -> + {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @498} -> + {F : @434} -> + {o : @473} -> + (hB : @606) -> + (hfn : @610) -> (hwt : @614) -> (hbind : @544) -> (hF : @554) -> (hA : @618) -> @583 +@633 := @600 @1 +@634 := @601 @1 +@638 := (n : @98) -> @634 @187 @19 @179 +@641 := @167 @193 @181 @531 +@642 := @547 @1 +@645 := @546 (@642 @500) @553 +@646 := @572 @1 +@656 := (hbind : @544) -> + (hF : @645) -> (hA : @618) -> (hne : @562) -> @565 (fun (ro : @564) => @571 (@646 @576 @548 @19)) +@666 := {A : @12} -> + {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @498} -> {F : @434} -> {o : @473} -> (hB : @638) -> (hfn : @610) -> (hwt : @641) -> @656 +@667 := @633 @2 +@669 := @634 @2 @19 +@671 := (n : @98) -> @669 @179 +@672 := @173 @181 +@673 := @672 @531 +@682 := {f : @98} -> + {fn : @123} -> + {args : @177} -> + {env : @498} -> {F : @434} -> {o : @473} -> (hB : @671) -> (hfn : @610) -> (hwt : @673) -> @656 +@683 := @667 @111 +@685 := (n : @98) -> @669 @111 +@686 := @607 @111 +@687 := @509 @686 +@688 := @687 @523 +@689 := @642 @111 +@690 := @546 @689 +@691 := @690 @553 +@692 := @615 @111 +@694 := @692 @193 @181 +@696 := @646 (@575 @111) +@704 := (hF : @691) -> (hA : @694) -> (hne : @562) -> @565 (fun (ro : @564) => @571 (@696 @548 @19)) +@713 := {fn : @123} -> + {args : @177} -> + {env : @498} -> + {F : @434} -> {o : @473} -> (hB : @685) -> (hfn : @688) -> (hwt : @673) -> (hbind : @544) -> @704 +@714 := @683 @143 +@716 := @687 (@522 @143) +@717 := @530 @143 +@718 := @672 @717 +@720 := @535 (@536 @143) +@732 := {args : @177} -> + {env : @498} -> + {F : @434} -> + {o : @473} -> + (hB : @685) -> (hfn : @716) -> (hwt : @718) -> (hbind : @534 (@720 @179 @114) @543) -> @704 +@733 := @714 @97 +@736 := @381 (@328 (@270 @90)) +@738 := @173 @736 @717 +@740 := @91 (@5 @500) +@745 := @740 (@381 (@91 (@57 @187) @90)) +@749 := @534 (@720 @745 @114) @543 +@751 := @91 (@5 @548) +@753 := @91 (@5 @525) +@758 := @751 (@753 (@91 (@57 @500) @90)) +@760 := @692 @758 @181 +@763 := @91 (@5 #14) +@765 := @91 (@5 @556) +@766 := #12 +@786 := {env : @498} -> + {F : @434} -> + {o : @473} -> + (hB : @685) -> + (hfn : @716) -> + (hwt : @738) -> + (hbind : @749) -> + (hF : @691) -> + (hA : @760) -> + (hne : @562) -> @565 (fun (ro : @564) => @571 (@696 (@763 (@765 (@91 (@57 @766) @90))) @19)) +@787 := @733 @121 +@790 := @328 (@342 (@284 @90)) +@792 := @173 @790 @717 +@806 := @534 (@720 @736 @114) (@542 (@115 (@106 @269) (@115 (@109 @327) (@115 (@112 @380) @114)))) +@811 := @753 (@740 (@91 (@57 @193) @90)) +@813 := @692 @811 @181 +@815 := @91 (@5 @766) +@834 := {F : @434} -> + {o : @473} -> + (hB : @685) -> + (hfn : @716) -> + (hwt : @792) -> + (hbind : @806) -> + (hF : @691) -> + (hA : @813) -> + (hne : @562) -> @565 (fun (ro : @564) => @571 (@696 (@765 (@815 (@91 (@57 @548) @90))) @19)) +@835 := @787 @122 +@836 := @400 @717 +@850 := @534 (@720 @790 @114) (@542 (@115 (@106 @283) (@115 (@109 @341) (@115 (@112 @327) @114)))) +@852 := @690 (@552 @122) +@854 := @692 @745 @181 +@855 := @567 @122 +@876 := {o : @473} -> + (hB : @685) -> + (hfn : @716) -> + (hwt : @836) -> + (hbind : @850) -> + (hF : @852) -> + (hA : @854) -> + (hne : @562) -> + @565 (fun (ro : @564) => @566 (@855 @193 @19) (@696 (@815 (@751 (@91 (@57 @525) @90))) @19)) +@877 := @835 @423 +@878 := @407 @717 +@892 := @534 (@720 @399 @114) (@542 (@115 (@106 @266) (@115 (@109 @324) (@115 (@112 @341) @114)))) +@893 := @692 @736 +@896 := @420 @193 @187 @179 +@897 := @893 @896 +@900 := @420 @500 @193 @187 +@920 := (hB : @685) -> + (hfn : @716) -> + (hwt : @878) -> + (hbind : @892) -> + (hF : @852) -> + (hA : @897) -> + (hne : @474 @900 @479) -> + @565 (fun (ro : @564) => @566 (@855 (@420 @548 @525 @500) @19) (@696 @758 @19)) +@921 := @877 @147 +@922 := @414 @717 +@936 := @534 (@720 @406 @114) (@542 (@115 (@106 @280) (@115 (@109 @338) (@115 (@112 @324) @114)))) +@937 := @692 @790 +@940 := @420 @187 @179 @181 +@960 := (hfn : @716) -> + (hwt : @922) -> + (hbind : @936) -> + (hF : @852) -> + (hA : @937 @940) -> + (hne : @474 @896 @479) -> + @565 (fun (ro : @564) => @566 (@855 (@420 @525 @500 @193) @19) (@696 @811 @19)) +@961 := Eq.refl.{1} +@964 := @921 (@961 @508 @686) +@965 := @418 @717 +@979 := @534 (@720 @413 @114) (@542 (@115 (@106 @295) (@115 (@109 @6) (@115 (@112 @338) @114)))) +@980 := @692 @399 +@983 := @420 @179 @181 @183 +@999 := (hwt : @965) -> + (hbind : @979) -> + (hF : @852) -> + (hA : @980 @983) -> + (hne : @474 @940 @479) -> @565 (fun (ro : @564) => @566 (@855 @900 @19) (@696 @745 @19)) +@1000 := @964 @417 +@1002 := @720 @97 @114 +@1005 := @534 @1002 (@542 @121) +@1006 := @692 @406 +@1009 := @420 @181 @183 @4 +@1024 := (hbind : @1005) -> + (hF : @852) -> + (hA : @1006 @1009) -> + (hne : @474 @983 @479) -> @565 (fun (ro : @564) => @566 (@855 @896 @19) (@696 @736 @19)) +@1027 := @1000 (@961 @533 @1002) +@1028 := @692 @413 +@1031 := @420 @183 @4 @15 +@1045 := (hF : @852) -> + (hA : @1028 @1031) -> + (hne : @474 @1009 @479) -> @565 (fun (ro : @564) => @566 (@855 @940 @19) (@696 @790 @19)) +@1048 := @1027 (@961 @545 @689) +@1062 := (hA : @692 @97 @423) -> + (hne : @474 @1031 @479) -> @565 (fun (ro : @564) => @566 (@855 @983 @19) (@696 @399 @19)) +@1063 := @1048 @471 +@1074 := (hne : @474 @423 @479) -> @565 (fun (ro : @564) => @566 (@855 @1009 @19) (@696 @406 @19)) +@1075 := @1063 @493 +@1081 := @566 (@855 @1031 @19) (@696 @413 @19) +@1083 := @565 (fun (ro : @564) => @1081) +@1085 := @565 (fun (__e_ro : @564) => @1081) +@1086 := LexLeanPreservation.Rust.RepresentableL +@1087 := @5 @17 +@1089 := @91 @61 @90 +@1093 := @1086 (@94 (@91 @1087 @1089)) +@1094 := (__e_hrep : @1093) -> @1085 +@1095 := fun (__e_hrep : @1093) => @1075 +@1096 := (s : @56) -> @1094 +@1097 := fun (s : @56) => @1095 +@1098 := (b : @3) -> @1096 +@1099 := fun (b : @3) => @1097 +@1100 := (a : @3) -> @1098 +@1101 := fun (a : @3) => @1099 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustCore.lean deleted file mode 100644 index d49009a7e..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int) (b : Int8) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_int a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i8 b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustCore.lex.tex new file mode 100644 index 000000000..28eae91f9 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustCore.lex.tex @@ -0,0 +1,495 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore.root : @992 := @993 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore.flags +@3 := Int +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.int +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.int +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_int @0 +@27 := @11 @0 +@29 := @27 @4 @15 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @29 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@37 := @36 @15 +@41 := {A : @10} -> (n : @3) -> @37 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := Int8 +@51 := LexLeanTarget.TargetSyntax.Value.i8 +@52 := @51 @15 +@55 := LexLeanTarget.TargetSyntax.Ty.fixed LexLeanTarget.TargetSyntax.IntKind.i8 +@56 := @51 @17 +@62 := {p : @8} -> {c : @9} -> {A : @10} -> (x : @50) -> @16 @56 @55 +@64 := LexLeanPreservation.Rust.wt_i8 @0 +@69 := {c : @9} -> {A : @10} -> (x : @50) -> @29 @56 @55 +@70 := @64 @1 +@74 := {A : @10} -> (x : @50) -> @37 @56 @55 +@75 := @70 @2 +@78 := (x : @50) -> @43 @56 @55 +@79 := @75 @15 +@81 := @43 @52 @55 +@82 := LexLeanTarget.TargetSyntax.Value +@83 := List.nil.{0} +@84 := List.cons.{0} +@85 := @83 @82 +@86 := @84 @82 +@88 := @86 @52 @85 +@90 := @86 @6 @88 +@91 := Nat +@94 := Prod.{0, 0} @91 @82 +@95 := 1 +@98 := Prod.mk.{0, 0} @91 @82 +@99 := @98 @95 +@100 := @99 @52 +@101 := 0 +@102 := @98 @101 +@103 := @102 @6 +@104 := @83 @94 +@105 := @84 @94 +@107 := @105 @103 @104 +@109 := @105 @100 @107 +@110 := Bool.false +@111 := LexLeanTarget.TargetSyntax.Function +@112 := LexLeanTarget.TargetSyntax.Program.functions +@113 := @112 @0 +@114 := LexLeanTarget.TargetSyntax.Ty +@115 := @83 @91 +@116 := @83 @114 +@117 := LexLeanTarget.TargetSyntax.Ty.unit +@118 := LexLeanTarget.TargetSyntax.Value.unit +@121 := LexLeanTarget.TargetSyntax.Expr.value @117 @118 +@126 := LexLeanTarget.TargetSyntax.Function.mk @115 @116 @117 @121 +@131 := List.getD.{0} @111 @113 @101 @126 +@135 := fun (__e_n : @91) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore.root @17 @101 +@136 := LexLeanPreservation.Rust.WTL +@144 := {p : @8} -> {c : @9} -> {A : @10} -> @136 @4 @15 @17 @85 @116 +@146 := LexLeanPreservation.Rust.wtl_nil @0 +@147 := @136 @0 +@153 := {c : @9} -> {A : @10} -> @147 @15 @17 @85 @116 +@154 := @146 @1 +@155 := @147 @1 +@159 := {A : @10} -> @155 @17 @85 @116 +@160 := @154 @2 +@161 := @155 @2 +@162 := @161 @85 +@163 := @162 @116 +@164 := List.{0} +@165 := @164 @82 +@166 := @164 @114 +@167 := #6 +@168 := @11 @167 +@169 := #5 +@170 := @168 @169 +@171 := #4 +@174 := @170 @171 @12 @4 +@175 := #7 +@180 := @136 @175 @167 @169 @4 @15 +@181 := #8 +@184 := @136 @181 @175 @167 +@186 := @86 @169 @12 +@187 := @184 @186 +@188 := @84 @114 +@190 := @188 @171 @4 +@200 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @82} -> {t : @114} -> {vs : @165} -> {ts : @166} -> (h : @174) -> (hs : @180) -> @187 @190 +@202 := LexLeanPreservation.Rust.wtl_cons @0 +@222 := {c : @9} -> + {A : @10} -> + {v : @82} -> + {t : @114} -> + {vs : @165} -> + {ts : @166} -> + (h : @27 @169 @171 @12 @4) -> (hs : @147 @167 @169 @4 @15) -> @147 @175 @167 @186 @190 +@223 := @202 @1 +@239 := {A : @10} -> + {v : @82} -> + {t : @114} -> + {vs : @165} -> + {ts : @166} -> (h : @36 @171 @12 @4) -> (hs : @155 @169 @4 @15) -> @155 @167 @186 @190 +@240 := @223 @2 +@242 := @43 @12 @4 +@244 := @161 @4 @15 +@252 := {v : @82} -> + {t : @114} -> {vs : @165} -> {ts : @166} -> (h : @242) -> (hs : @244) -> @161 @186 @190 +@253 := @240 @52 +@254 := @51 @171 +@256 := @43 @254 @4 +@257 := @51 @167 +@258 := @86 @257 +@266 := {t : @114} -> + {vs : @165} -> {ts : @166} -> (h : @256) -> (hs : @244) -> @161 (@258 @12) @190 +@267 := @253 @55 +@268 := @51 @12 +@270 := @43 @268 @55 +@271 := @51 @169 +@272 := @86 @271 +@274 := @161 (@272 @12) +@275 := @188 @55 +@276 := @275 @4 +@281 := {vs : @165} -> {ts : @166} -> (h : @270) -> (hs : @244) -> @274 @276 +@282 := @267 @85 +@283 := @51 @4 +@285 := @43 @283 @55 +@286 := @162 @15 +@288 := @86 @254 @85 +@293 := {ts : @166} -> (h : @285) -> (hs : @286) -> @161 @288 @276 +@294 := @282 @116 +@296 := @86 @268 @85 +@297 := @161 @296 +@298 := @275 @116 +@301 := (h : @81) -> (hs : @163) -> @297 @298 +@302 := @294 @79 +@304 := @86 @283 @85 +@306 := @161 @304 @298 +@307 := (hs : @163) -> @306 +@308 := @302 @160 +@310 := @161 @88 @298 +@311 := @240 @6 +@312 := @5 @169 +@314 := @43 @312 @4 +@315 := @5 @175 +@316 := @86 @315 +@324 := {t : @114} -> + {vs : @165} -> {ts : @166} -> (h : @314) -> (hs : @244) -> @161 (@316 @12) @190 +@325 := @311 @7 +@326 := @5 @171 +@328 := @43 @326 @7 +@329 := @5 @167 +@330 := @86 @329 +@332 := @161 (@330 @12) +@333 := @188 @7 +@334 := @333 @4 +@339 := {vs : @165} -> {ts : @166} -> (h : @328) -> (hs : @244) -> @332 @334 +@340 := @325 @88 +@341 := @5 @12 +@343 := @43 @341 @7 +@344 := @297 @15 +@346 := @86 @312 @288 +@347 := @161 @346 +@351 := {ts : @166} -> (h : @343) -> (hs : @344) -> @347 @334 +@352 := @340 @298 +@354 := @86 @326 @296 +@355 := @161 @354 +@356 := @333 @298 +@359 := (h : @49) -> (hs : @306) -> @355 @356 +@360 := @352 @47 +@362 := @86 @341 @304 +@363 := @161 @362 +@365 := (hs : @310) -> @363 @356 +@366 := @360 @308 +@367 := @161 @90 +@368 := @367 @356 +@369 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.denote +@371 := @369 @4 @15 +@372 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.__fits_0 +@374 := @372 @4 @15 +@377 := Coverage.Prims.conversions @4 @15 +@378 := UInt16 +@379 := Option.{0} +@380 := @379 @378 +@381 := Int64 +@382 := @379 @381 +@383 := LexLeanTarget.TargetSyntax.Value.u16 +@384 := LexLeanPreservation.encOption +@386 := @384 @378 @383 +@387 := LexLeanTarget.TargetSyntax.Value.i64 +@389 := @384 @381 @387 +@395 := LexLeanPreservation.encPair @380 @382 @386 @389 @377 +@398 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.root @4 @15 +@399 := Bool +@400 := Ne.{1} +@401 := LexLeanPreservation.Obs +@402 := @400 @401 +@403 := LexLeanPreservation.Rel +@406 := @402 (@403 @15 @17) +@407 := LexLeanPreservation.Obs.stuck +@410 := (f : @399) -> (v : @82) -> @406 @407 +@412 := LexLeanPreservation.Rust.rel_ne_stuck @374 +@419 := (v : @82) -> @402 (@403 (@372 @12 @4) @17) @407 +@420 := @412 @395 +@424 := @402 (@403 @374 @395) @407 +@425 := @164 @94 +@426 := LexLeanPreservation.Rust.FunSem +@427 := #9 +@433 := (n : @91) -> @426 @427 @181 @175 @17 @167 +@434 := Eq.{1} +@435 := @379 @111 +@436 := @434 @435 +@443 := LexLeanRuntime.index (@164 @111) @111 (LexLeanRuntime.instIndexableList @111) +@447 := @436 (@443 (@112 @427) @167) +@448 := Option.some.{0} +@449 := @448 @111 +@450 := @449 @169 +@451 := @447 @450 +@452 := #10 +@456 := @136 @452 @427 @181 @169 +@457 := LexLeanTarget.TargetSyntax.Function.types +@458 := @457 @167 +@459 := @456 @458 +@460 := @379 @425 +@461 := @434 @460 +@462 := LexLeanTarget.TargetSemantics.bindAll +@463 := LexLeanTarget.TargetSyntax.Function.parameters +@468 := @461 (@462 (@463 @175) @167 @104) +@469 := @448 @425 +@470 := @469 @169 +@471 := @468 @470 +@472 := @379 @399 +@473 := @434 @472 +@474 := LexLeanPreservation.Rust.fnFallible +@475 := #11 +@478 := @473 (@474 @475 @427) +@479 := @448 @399 +@480 := @479 @169 +@481 := @478 @480 +@482 := LexLeanPreservation.RunConv +@483 := #13 +@487 := @482 @483 @452 @181 @169 +@489 := @402 @167 @407 +@490 := Exists.{1} +@491 := LexLeanPreservation.Rust.ROut +@492 := @490 @491 +@493 := And +@494 := LexLeanPreservation.Rust.RealizesFn +@498 := @493 (@494 @427 @181 @17) +@499 := LexLeanPreservation.Rust.RCI +@501 := @499 #15 +@502 := LexLeanPreservation.Rust.fnIdent +@503 := @502 @483 +@510 := (hne : @489) -> @492 (fun (ro : @491) => @498 (@501 @503 @475 @17)) +@525 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @425} -> + {F : @399} -> + {o : @401} -> + (hB : @433) -> + (hfn : @451) -> (hwt : @459) -> (hbind : @471) -> (hF : @481) -> (hA : @487) -> @510 +@527 := LexLeanPreservation.Rust.compose @0 +@528 := @426 @0 +@533 := (n : @91) -> @528 @181 @175 @17 @167 +@534 := @443 @113 +@537 := @436 (@534 @167) @450 +@541 := @147 @427 @181 @169 @458 +@542 := @482 @0 +@545 := @542 @452 @181 @169 +@559 := {c : @9} -> + {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @425} -> + {F : @399} -> + {o : @401} -> + (hB : @533) -> + (hfn : @537) -> (hwt : @541) -> (hbind : @471) -> (hF : @481) -> (hA : @545) -> @510 +@560 := @527 @1 +@561 := @528 @1 +@565 := (n : @91) -> @561 @175 @17 @167 +@568 := @155 @181 @169 @458 +@569 := @474 @1 +@572 := @473 (@569 @427) @480 +@573 := @499 @1 +@583 := (hbind : @471) -> + (hF : @572) -> (hA : @545) -> (hne : @489) -> @492 (fun (ro : @491) => @498 (@573 @503 @475 @17)) +@593 := {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @425} -> {F : @399} -> {o : @401} -> (hB : @565) -> (hfn : @537) -> (hwt : @568) -> @583 +@594 := @560 @2 +@596 := @561 @2 @17 +@598 := (n : @91) -> @596 @167 +@599 := @161 @169 +@600 := @599 @458 +@609 := {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @425} -> {F : @399} -> {o : @401} -> (hB : @598) -> (hfn : @537) -> (hwt : @600) -> @583 +@610 := @594 @101 +@612 := (n : @91) -> @596 @101 +@613 := @534 @101 +@614 := @436 @613 +@615 := @614 @450 +@616 := @569 @101 +@617 := @473 @616 +@618 := @617 @480 +@619 := @542 @101 +@621 := @619 @181 @169 +@623 := @573 (@502 @101) +@631 := (hF : @618) -> (hA : @621) -> (hne : @489) -> @492 (fun (ro : @491) => @498 (@623 @475 @17)) +@640 := {fn : @111} -> + {args : @165} -> + {env : @425} -> + {F : @399} -> {o : @401} -> (hB : @612) -> (hfn : @615) -> (hwt : @600) -> (hbind : @471) -> @631 +@641 := @610 @131 +@643 := @614 (@449 @131) +@644 := @457 @131 +@645 := @599 @644 +@647 := @462 (@463 @131) +@659 := {args : @165} -> + {env : @425} -> + {F : @399} -> + {o : @401} -> + (hB : @612) -> (hfn : @643) -> (hwt : @645) -> (hbind : @461 (@647 @167 @104) @470) -> @631 +@660 := @641 @90 +@662 := @316 (@258 @85) +@664 := @161 @662 @644 +@670 := @86 (@5 @181) (@86 (@51 @175) @85) +@674 := @461 (@647 @670 @104) @470 +@680 := @86 (@5 @452) (@86 (@51 @427) @85) +@682 := @619 @680 @169 +@684 := @86 (@5 @483) +@685 := #12 +@704 := {env : @425} -> + {F : @399} -> + {o : @401} -> + (hB : @612) -> + (hfn : @643) -> + (hwt : @664) -> + (hbind : @674) -> + (hF : @618) -> + (hA : @682) -> + (hne : @489) -> @492 (fun (ro : @491) => @498 (@623 (@684 (@86 (@51 @685) @85)) @17)) +@705 := @660 @109 +@707 := @330 (@272 @85) +@709 := @161 @707 @644 +@720 := @461 (@647 @662 @104) (@469 (@105 (@99 @257) (@105 (@102 @315) @104))) +@726 := @86 (@5 @427) (@86 (@51 @181) @85) +@748 := {F : @399} -> + {o : @401} -> + (hB : @612) -> + (hfn : @643) -> + (hwt : @709) -> + (hbind : @720) -> + (hF : @618) -> + (hA : @619 @726 @169) -> + (hne : @489) -> @492 (fun (ro : @491) => @498 (@623 (@86 (@5 @685) (@86 (@51 @475) @85)) @17)) +@749 := @705 @110 +@750 := @347 @644 +@761 := @461 (@647 @707 @104) (@469 (@105 (@99 @271) (@105 (@102 @329) @104))) +@763 := @617 (@479 @110) +@765 := @619 @670 @169 +@766 := @494 @110 +@788 := {o : @401} -> + (hB : @612) -> + (hfn : @643) -> + (hwt : @750) -> + (hbind : @761) -> + (hF : @763) -> + (hA : @765) -> + (hne : @489) -> + @492 (fun (ro : @491) => @493 (@766 @181 @17) (@623 (@86 (@5 @475) (@86 (@51 @452) @85)) @17)) +@789 := @749 @371 +@790 := @355 @644 +@801 := @461 (@647 @346 @104) (@469 (@105 (@99 @254) (@105 (@102 @312) @104))) +@802 := @619 @662 +@804 := @369 @175 @167 +@805 := @802 @804 +@807 := @369 @181 @175 +@826 := (hB : @612) -> + (hfn : @643) -> + (hwt : @790) -> + (hbind : @801) -> + (hF : @763) -> + (hA : @805) -> + (hne : @402 @807 @407) -> + @492 (fun (ro : @491) => @493 (@766 (@369 @452 @427) @17) (@623 @680 @17)) +@827 := @789 @135 +@828 := @363 @644 +@839 := @461 (@647 @354 @104) (@469 (@105 (@99 @268) (@105 (@102 @326) @104))) +@840 := @619 @707 +@842 := @369 @167 @169 +@861 := (hfn : @643) -> + (hwt : @828) -> + (hbind : @839) -> + (hF : @763) -> + (hA : @840 @842) -> + (hne : @402 @804 @407) -> + @492 (fun (ro : @491) => @493 (@766 (@369 @427 @181) @17) (@623 @726 @17)) +@862 := Eq.refl.{1} +@865 := @827 (@862 @435 @613) +@866 := @367 @644 +@877 := @461 (@647 @362 @104) (@469 (@105 (@99 @283) (@105 (@102 @341) @104))) +@878 := @619 @346 +@880 := @369 @169 @171 +@896 := (hwt : @866) -> + (hbind : @877) -> + (hF : @763) -> + (hA : @878 @880) -> + (hne : @402 @842 @407) -> @492 (fun (ro : @491) => @493 (@766 @807 @17) (@623 @670 @17)) +@897 := @865 @366 +@899 := @647 @90 @104 +@902 := @461 @899 (@469 @109) +@903 := @619 @354 +@905 := @369 @171 @12 +@920 := (hbind : @902) -> + (hF : @763) -> + (hA : @903 @905) -> + (hne : @402 @880 @407) -> @492 (fun (ro : @491) => @493 (@766 @804 @17) (@623 @662 @17)) +@923 := @897 (@862 @460 @899) +@924 := @619 @362 +@926 := @369 @12 @4 +@940 := (hF : @763) -> + (hA : @924 @926) -> + (hne : @402 @905 @407) -> @492 (fun (ro : @491) => @493 (@766 @842 @17) (@623 @707 @17)) +@943 := @923 (@862 @472 @616) +@957 := (hA : @619 @90 @371) -> + (hne : @402 @926 @407) -> @492 (fun (ro : @491) => @493 (@766 @880 @17) (@623 @346 @17)) +@958 := @943 @398 +@969 := (hne : @402 @371 @407) -> @492 (fun (ro : @491) => @493 (@766 @905 @17) (@623 @354 @17)) +@970 := @958 @420 +@976 := @493 (@766 @926 @17) (@623 @362 @17) +@978 := @492 (fun (ro : @491) => @976) +@980 := @492 (fun (__e_ro : @491) => @976) +@981 := LexLeanPreservation.Rust.RepresentableL +@982 := @5 @15 +@984 := @86 @56 @85 +@987 := @981 (@86 @982 @984) +@988 := (__e_hrep : @987) -> @980 +@989 := fun (__e_hrep : @987) => @970 +@990 := (b : @50) -> @988 +@991 := fun (b : @50) => @989 +@992 := (a : @3) -> @990 +@993 := fun (a : @3) => @991 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustStd.lean deleted file mode 100644 index 6afaad490..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int) (b : Int8) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_int a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i8 b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustStd.lex.tex new file mode 100644 index 000000000..ef01b7599 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustStd.lex.tex @@ -0,0 +1,495 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd.root : @992 := @993 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd.flags +@3 := Int +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.int +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.int +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_int @0 +@27 := @11 @0 +@29 := @27 @4 @15 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @29 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@37 := @36 @15 +@41 := {A : @10} -> (n : @3) -> @37 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := Int8 +@51 := LexLeanTarget.TargetSyntax.Value.i8 +@52 := @51 @15 +@55 := LexLeanTarget.TargetSyntax.Ty.fixed LexLeanTarget.TargetSyntax.IntKind.i8 +@56 := @51 @17 +@62 := {p : @8} -> {c : @9} -> {A : @10} -> (x : @50) -> @16 @56 @55 +@64 := LexLeanPreservation.Rust.wt_i8 @0 +@69 := {c : @9} -> {A : @10} -> (x : @50) -> @29 @56 @55 +@70 := @64 @1 +@74 := {A : @10} -> (x : @50) -> @37 @56 @55 +@75 := @70 @2 +@78 := (x : @50) -> @43 @56 @55 +@79 := @75 @15 +@81 := @43 @52 @55 +@82 := LexLeanTarget.TargetSyntax.Value +@83 := List.nil.{0} +@84 := List.cons.{0} +@85 := @83 @82 +@86 := @84 @82 +@88 := @86 @52 @85 +@90 := @86 @6 @88 +@91 := Nat +@94 := Prod.{0, 0} @91 @82 +@95 := 1 +@98 := Prod.mk.{0, 0} @91 @82 +@99 := @98 @95 +@100 := @99 @52 +@101 := 0 +@102 := @98 @101 +@103 := @102 @6 +@104 := @83 @94 +@105 := @84 @94 +@107 := @105 @103 @104 +@109 := @105 @100 @107 +@110 := Bool.false +@111 := LexLeanTarget.TargetSyntax.Function +@112 := LexLeanTarget.TargetSyntax.Program.functions +@113 := @112 @0 +@114 := LexLeanTarget.TargetSyntax.Ty +@115 := @83 @91 +@116 := @83 @114 +@117 := LexLeanTarget.TargetSyntax.Ty.unit +@118 := LexLeanTarget.TargetSyntax.Value.unit +@121 := LexLeanTarget.TargetSyntax.Expr.value @117 @118 +@126 := LexLeanTarget.TargetSyntax.Function.mk @115 @116 @117 @121 +@131 := List.getD.{0} @111 @113 @101 @126 +@135 := fun (__e_n : @91) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd.root @17 @101 +@136 := LexLeanPreservation.Rust.WTL +@144 := {p : @8} -> {c : @9} -> {A : @10} -> @136 @4 @15 @17 @85 @116 +@146 := LexLeanPreservation.Rust.wtl_nil @0 +@147 := @136 @0 +@153 := {c : @9} -> {A : @10} -> @147 @15 @17 @85 @116 +@154 := @146 @1 +@155 := @147 @1 +@159 := {A : @10} -> @155 @17 @85 @116 +@160 := @154 @2 +@161 := @155 @2 +@162 := @161 @85 +@163 := @162 @116 +@164 := List.{0} +@165 := @164 @82 +@166 := @164 @114 +@167 := #6 +@168 := @11 @167 +@169 := #5 +@170 := @168 @169 +@171 := #4 +@174 := @170 @171 @12 @4 +@175 := #7 +@180 := @136 @175 @167 @169 @4 @15 +@181 := #8 +@184 := @136 @181 @175 @167 +@186 := @86 @169 @12 +@187 := @184 @186 +@188 := @84 @114 +@190 := @188 @171 @4 +@200 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @82} -> {t : @114} -> {vs : @165} -> {ts : @166} -> (h : @174) -> (hs : @180) -> @187 @190 +@202 := LexLeanPreservation.Rust.wtl_cons @0 +@222 := {c : @9} -> + {A : @10} -> + {v : @82} -> + {t : @114} -> + {vs : @165} -> + {ts : @166} -> + (h : @27 @169 @171 @12 @4) -> (hs : @147 @167 @169 @4 @15) -> @147 @175 @167 @186 @190 +@223 := @202 @1 +@239 := {A : @10} -> + {v : @82} -> + {t : @114} -> + {vs : @165} -> + {ts : @166} -> (h : @36 @171 @12 @4) -> (hs : @155 @169 @4 @15) -> @155 @167 @186 @190 +@240 := @223 @2 +@242 := @43 @12 @4 +@244 := @161 @4 @15 +@252 := {v : @82} -> + {t : @114} -> {vs : @165} -> {ts : @166} -> (h : @242) -> (hs : @244) -> @161 @186 @190 +@253 := @240 @52 +@254 := @51 @171 +@256 := @43 @254 @4 +@257 := @51 @167 +@258 := @86 @257 +@266 := {t : @114} -> + {vs : @165} -> {ts : @166} -> (h : @256) -> (hs : @244) -> @161 (@258 @12) @190 +@267 := @253 @55 +@268 := @51 @12 +@270 := @43 @268 @55 +@271 := @51 @169 +@272 := @86 @271 +@274 := @161 (@272 @12) +@275 := @188 @55 +@276 := @275 @4 +@281 := {vs : @165} -> {ts : @166} -> (h : @270) -> (hs : @244) -> @274 @276 +@282 := @267 @85 +@283 := @51 @4 +@285 := @43 @283 @55 +@286 := @162 @15 +@288 := @86 @254 @85 +@293 := {ts : @166} -> (h : @285) -> (hs : @286) -> @161 @288 @276 +@294 := @282 @116 +@296 := @86 @268 @85 +@297 := @161 @296 +@298 := @275 @116 +@301 := (h : @81) -> (hs : @163) -> @297 @298 +@302 := @294 @79 +@304 := @86 @283 @85 +@306 := @161 @304 @298 +@307 := (hs : @163) -> @306 +@308 := @302 @160 +@310 := @161 @88 @298 +@311 := @240 @6 +@312 := @5 @169 +@314 := @43 @312 @4 +@315 := @5 @175 +@316 := @86 @315 +@324 := {t : @114} -> + {vs : @165} -> {ts : @166} -> (h : @314) -> (hs : @244) -> @161 (@316 @12) @190 +@325 := @311 @7 +@326 := @5 @171 +@328 := @43 @326 @7 +@329 := @5 @167 +@330 := @86 @329 +@332 := @161 (@330 @12) +@333 := @188 @7 +@334 := @333 @4 +@339 := {vs : @165} -> {ts : @166} -> (h : @328) -> (hs : @244) -> @332 @334 +@340 := @325 @88 +@341 := @5 @12 +@343 := @43 @341 @7 +@344 := @297 @15 +@346 := @86 @312 @288 +@347 := @161 @346 +@351 := {ts : @166} -> (h : @343) -> (hs : @344) -> @347 @334 +@352 := @340 @298 +@354 := @86 @326 @296 +@355 := @161 @354 +@356 := @333 @298 +@359 := (h : @49) -> (hs : @306) -> @355 @356 +@360 := @352 @47 +@362 := @86 @341 @304 +@363 := @161 @362 +@365 := (hs : @310) -> @363 @356 +@366 := @360 @308 +@367 := @161 @90 +@368 := @367 @356 +@369 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.denote +@371 := @369 @4 @15 +@372 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.__fits_0 +@374 := @372 @4 @15 +@377 := Coverage.Prims.conversions @4 @15 +@378 := UInt16 +@379 := Option.{0} +@380 := @379 @378 +@381 := Int64 +@382 := @379 @381 +@383 := LexLeanTarget.TargetSyntax.Value.u16 +@384 := LexLeanPreservation.encOption +@386 := @384 @378 @383 +@387 := LexLeanTarget.TargetSyntax.Value.i64 +@389 := @384 @381 @387 +@395 := LexLeanPreservation.encPair @380 @382 @386 @389 @377 +@398 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.root @4 @15 +@399 := Bool +@400 := Ne.{1} +@401 := LexLeanPreservation.Obs +@402 := @400 @401 +@403 := LexLeanPreservation.Rel +@406 := @402 (@403 @15 @17) +@407 := LexLeanPreservation.Obs.stuck +@410 := (f : @399) -> (v : @82) -> @406 @407 +@412 := LexLeanPreservation.Rust.rel_ne_stuck @374 +@419 := (v : @82) -> @402 (@403 (@372 @12 @4) @17) @407 +@420 := @412 @395 +@424 := @402 (@403 @374 @395) @407 +@425 := @164 @94 +@426 := LexLeanPreservation.Rust.FunSem +@427 := #9 +@433 := (n : @91) -> @426 @427 @181 @175 @17 @167 +@434 := Eq.{1} +@435 := @379 @111 +@436 := @434 @435 +@443 := LexLeanRuntime.index (@164 @111) @111 (LexLeanRuntime.instIndexableList @111) +@447 := @436 (@443 (@112 @427) @167) +@448 := Option.some.{0} +@449 := @448 @111 +@450 := @449 @169 +@451 := @447 @450 +@452 := #10 +@456 := @136 @452 @427 @181 @169 +@457 := LexLeanTarget.TargetSyntax.Function.types +@458 := @457 @167 +@459 := @456 @458 +@460 := @379 @425 +@461 := @434 @460 +@462 := LexLeanTarget.TargetSemantics.bindAll +@463 := LexLeanTarget.TargetSyntax.Function.parameters +@468 := @461 (@462 (@463 @175) @167 @104) +@469 := @448 @425 +@470 := @469 @169 +@471 := @468 @470 +@472 := @379 @399 +@473 := @434 @472 +@474 := LexLeanPreservation.Rust.fnFallible +@475 := #11 +@478 := @473 (@474 @475 @427) +@479 := @448 @399 +@480 := @479 @169 +@481 := @478 @480 +@482 := LexLeanPreservation.RunConv +@483 := #13 +@487 := @482 @483 @452 @181 @169 +@489 := @402 @167 @407 +@490 := Exists.{1} +@491 := LexLeanPreservation.Rust.ROut +@492 := @490 @491 +@493 := And +@494 := LexLeanPreservation.Rust.RealizesFn +@498 := @493 (@494 @427 @181 @17) +@499 := LexLeanPreservation.Rust.RCI +@501 := @499 #15 +@502 := LexLeanPreservation.Rust.fnIdent +@503 := @502 @483 +@510 := (hne : @489) -> @492 (fun (ro : @491) => @498 (@501 @503 @475 @17)) +@525 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @425} -> + {F : @399} -> + {o : @401} -> + (hB : @433) -> + (hfn : @451) -> (hwt : @459) -> (hbind : @471) -> (hF : @481) -> (hA : @487) -> @510 +@527 := LexLeanPreservation.Rust.compose @0 +@528 := @426 @0 +@533 := (n : @91) -> @528 @181 @175 @17 @167 +@534 := @443 @113 +@537 := @436 (@534 @167) @450 +@541 := @147 @427 @181 @169 @458 +@542 := @482 @0 +@545 := @542 @452 @181 @169 +@559 := {c : @9} -> + {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @425} -> + {F : @399} -> + {o : @401} -> + (hB : @533) -> + (hfn : @537) -> (hwt : @541) -> (hbind : @471) -> (hF : @481) -> (hA : @545) -> @510 +@560 := @527 @1 +@561 := @528 @1 +@565 := (n : @91) -> @561 @175 @17 @167 +@568 := @155 @181 @169 @458 +@569 := @474 @1 +@572 := @473 (@569 @427) @480 +@573 := @499 @1 +@583 := (hbind : @471) -> + (hF : @572) -> (hA : @545) -> (hne : @489) -> @492 (fun (ro : @491) => @498 (@573 @503 @475 @17)) +@593 := {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @425} -> {F : @399} -> {o : @401} -> (hB : @565) -> (hfn : @537) -> (hwt : @568) -> @583 +@594 := @560 @2 +@596 := @561 @2 @17 +@598 := (n : @91) -> @596 @167 +@599 := @161 @169 +@600 := @599 @458 +@609 := {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @425} -> {F : @399} -> {o : @401} -> (hB : @598) -> (hfn : @537) -> (hwt : @600) -> @583 +@610 := @594 @101 +@612 := (n : @91) -> @596 @101 +@613 := @534 @101 +@614 := @436 @613 +@615 := @614 @450 +@616 := @569 @101 +@617 := @473 @616 +@618 := @617 @480 +@619 := @542 @101 +@621 := @619 @181 @169 +@623 := @573 (@502 @101) +@631 := (hF : @618) -> (hA : @621) -> (hne : @489) -> @492 (fun (ro : @491) => @498 (@623 @475 @17)) +@640 := {fn : @111} -> + {args : @165} -> + {env : @425} -> + {F : @399} -> {o : @401} -> (hB : @612) -> (hfn : @615) -> (hwt : @600) -> (hbind : @471) -> @631 +@641 := @610 @131 +@643 := @614 (@449 @131) +@644 := @457 @131 +@645 := @599 @644 +@647 := @462 (@463 @131) +@659 := {args : @165} -> + {env : @425} -> + {F : @399} -> + {o : @401} -> + (hB : @612) -> (hfn : @643) -> (hwt : @645) -> (hbind : @461 (@647 @167 @104) @470) -> @631 +@660 := @641 @90 +@662 := @316 (@258 @85) +@664 := @161 @662 @644 +@670 := @86 (@5 @181) (@86 (@51 @175) @85) +@674 := @461 (@647 @670 @104) @470 +@680 := @86 (@5 @452) (@86 (@51 @427) @85) +@682 := @619 @680 @169 +@684 := @86 (@5 @483) +@685 := #12 +@704 := {env : @425} -> + {F : @399} -> + {o : @401} -> + (hB : @612) -> + (hfn : @643) -> + (hwt : @664) -> + (hbind : @674) -> + (hF : @618) -> + (hA : @682) -> + (hne : @489) -> @492 (fun (ro : @491) => @498 (@623 (@684 (@86 (@51 @685) @85)) @17)) +@705 := @660 @109 +@707 := @330 (@272 @85) +@709 := @161 @707 @644 +@720 := @461 (@647 @662 @104) (@469 (@105 (@99 @257) (@105 (@102 @315) @104))) +@726 := @86 (@5 @427) (@86 (@51 @181) @85) +@748 := {F : @399} -> + {o : @401} -> + (hB : @612) -> + (hfn : @643) -> + (hwt : @709) -> + (hbind : @720) -> + (hF : @618) -> + (hA : @619 @726 @169) -> + (hne : @489) -> @492 (fun (ro : @491) => @498 (@623 (@86 (@5 @685) (@86 (@51 @475) @85)) @17)) +@749 := @705 @110 +@750 := @347 @644 +@761 := @461 (@647 @707 @104) (@469 (@105 (@99 @271) (@105 (@102 @329) @104))) +@763 := @617 (@479 @110) +@765 := @619 @670 @169 +@766 := @494 @110 +@788 := {o : @401} -> + (hB : @612) -> + (hfn : @643) -> + (hwt : @750) -> + (hbind : @761) -> + (hF : @763) -> + (hA : @765) -> + (hne : @489) -> + @492 (fun (ro : @491) => @493 (@766 @181 @17) (@623 (@86 (@5 @475) (@86 (@51 @452) @85)) @17)) +@789 := @749 @371 +@790 := @355 @644 +@801 := @461 (@647 @346 @104) (@469 (@105 (@99 @254) (@105 (@102 @312) @104))) +@802 := @619 @662 +@804 := @369 @175 @167 +@805 := @802 @804 +@807 := @369 @181 @175 +@826 := (hB : @612) -> + (hfn : @643) -> + (hwt : @790) -> + (hbind : @801) -> + (hF : @763) -> + (hA : @805) -> + (hne : @402 @807 @407) -> + @492 (fun (ro : @491) => @493 (@766 (@369 @452 @427) @17) (@623 @680 @17)) +@827 := @789 @135 +@828 := @363 @644 +@839 := @461 (@647 @354 @104) (@469 (@105 (@99 @268) (@105 (@102 @326) @104))) +@840 := @619 @707 +@842 := @369 @167 @169 +@861 := (hfn : @643) -> + (hwt : @828) -> + (hbind : @839) -> + (hF : @763) -> + (hA : @840 @842) -> + (hne : @402 @804 @407) -> + @492 (fun (ro : @491) => @493 (@766 (@369 @427 @181) @17) (@623 @726 @17)) +@862 := Eq.refl.{1} +@865 := @827 (@862 @435 @613) +@866 := @367 @644 +@877 := @461 (@647 @362 @104) (@469 (@105 (@99 @283) (@105 (@102 @341) @104))) +@878 := @619 @346 +@880 := @369 @169 @171 +@896 := (hwt : @866) -> + (hbind : @877) -> + (hF : @763) -> + (hA : @878 @880) -> + (hne : @402 @842 @407) -> @492 (fun (ro : @491) => @493 (@766 @807 @17) (@623 @670 @17)) +@897 := @865 @366 +@899 := @647 @90 @104 +@902 := @461 @899 (@469 @109) +@903 := @619 @354 +@905 := @369 @171 @12 +@920 := (hbind : @902) -> + (hF : @763) -> + (hA : @903 @905) -> + (hne : @402 @880 @407) -> @492 (fun (ro : @491) => @493 (@766 @804 @17) (@623 @662 @17)) +@923 := @897 (@862 @460 @899) +@924 := @619 @362 +@926 := @369 @12 @4 +@940 := (hF : @763) -> + (hA : @924 @926) -> + (hne : @402 @905 @407) -> @492 (fun (ro : @491) => @493 (@766 @842 @17) (@623 @707 @17)) +@943 := @923 (@862 @472 @616) +@957 := (hA : @619 @90 @371) -> + (hne : @402 @926 @407) -> @492 (fun (ro : @491) => @493 (@766 @880 @17) (@623 @346 @17)) +@958 := @943 @398 +@969 := (hne : @402 @371 @407) -> @492 (fun (ro : @491) => @493 (@766 @905 @17) (@623 @354 @17)) +@970 := @958 @420 +@976 := @493 (@766 @926 @17) (@623 @362 @17) +@978 := @492 (fun (ro : @491) => @976) +@980 := @492 (fun (__e_ro : @491) => @976) +@981 := LexLeanPreservation.Rust.RepresentableL +@982 := @5 @15 +@984 := @86 @56 @85 +@987 := @981 (@86 @982 @984) +@988 := (__e_hrep : @987) -> @980 +@989 := fun (__e_hrep : @987) => @970 +@990 := (b : @50) -> @988 +@991 := fun (b : @50) => @989 +@992 := (a : @3) -> @990 +@993 := fun (a : @3) => @991 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R26/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R26/Compose/RustStd.lean deleted file mode 100644 index e0b1d7fbf..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R26/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (xs : (List Nat)) (b : ByteArray) (i : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) xs), (_root_.LexLeanTarget.TargetSyntax.Value.bytes b), (_root_.LexLeanTarget.TargetSyntax.Value.nat i)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.denote xs b i) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) xs), (_root_.LexLeanTarget.TargetSyntax.Value.bytes b), (_root_.LexLeanTarget.TargetSyntax.Value.nat i)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat) xs) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_bytes b) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat i) _root_.LexLeanPreservation.Rust.wtl_nil))) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.root xs b i) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R26/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R26/Compose/RustStd.lex.tex new file mode 100644 index 000000000..773fdbe1d --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R26/Compose/RustStd.lex.tex @@ -0,0 +1,604 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd.root : @1256 := @1257 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd.flags +@3 := Nat +@4 := List.{0} +@5 := @4 @3 +@6 := #3 +@7 := LexLeanTarget.TargetSyntax.Value.nat +@8 := LexLeanPreservation.encList +@9 := @8 @3 +@10 := @9 @7 +@11 := @10 @6 +@12 := LexLeanTarget.TargetSyntax.Ty.nat +@13 := LexLeanTarget.TargetSyntax.Ty.list +@14 := @13 @12 +@15 := #0 +@16 := LexLeanTarget.TargetSyntax.Program +@17 := LexLeanPreservation.Rust.RCrate +@18 := LexLeanPreservation.Rust.Flags +@19 := LexLeanPreservation.Rust.WT +@20 := @19 @6 +@21 := #2 +@22 := @20 @21 +@23 := #1 +@24 := @22 @23 +@25 := @7 @15 +@31 := {p : @16} -> {c : @17} -> {A : @18} -> (n : @3) -> @24 @25 @12 +@33 := LexLeanPreservation.Rust.wt_nat @0 +@34 := @19 @0 +@36 := @34 @21 @23 +@41 := {c : @17} -> {A : @18} -> (n : @3) -> @36 @25 @12 +@42 := @33 @1 +@43 := @34 @1 +@44 := @43 @23 +@48 := {A : @18} -> (n : @3) -> @44 @25 @12 +@49 := @42 @2 +@50 := @43 @2 +@51 := @50 @25 +@52 := @51 @12 +@53 := (n : @3) -> @52 +@55 := fun (__x : @3) => @49 @15 +@56 := Sort 1 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := (a._@._internal._hyg.#0 : @15) -> @57 +@59 := LexLeanTarget.TargetSyntax.Ty +@60 := #6 +@61 := @19 @60 +@62 := #5 +@63 := @61 @62 +@64 := #4 +@65 := @63 @64 +@66 := @21 @15 +@69 := (x : @21) -> @65 @66 @23 +@70 := @4 @6 +@71 := #7 +@74 := @19 @71 @60 @62 +@77 := @8 @64 @6 @15 +@78 := @74 @77 +@79 := @13 @21 +@88 := {p : @16} -> + {c : @17} -> + {A : @18} -> {α : @56} -> {e : @58} -> {t : @59} -> (h : @69) -> (xs : @70) -> @78 @79 +@90 := LexLeanPreservation.Rust.wt_encList @0 +@92 := @34 @62 @64 +@106 := {c : @17} -> + {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @21) -> @92 @66 @23) -> (xs : @70) -> @34 @60 @62 @77 @79 +@107 := @90 @1 +@108 := @43 @64 +@120 := {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @21) -> @108 @66 @23) -> (xs : @70) -> @43 @62 @77 @79 +@121 := @107 @2 +@123 := @50 @66 @23 +@131 := {α : @56} -> {e : @58} -> {t : @59} -> (h : (x : @21) -> @123) -> (xs : @70) -> @50 @77 @79 +@132 := @121 @3 +@142 := {e : (a._@._internal._hyg.#0 : @3) -> @57} -> + {t : @59} -> (h : (x : @3) -> @123) -> (xs : @5) -> @50 (@9 @6 @15) @79 +@143 := @132 @7 +@145 := (x : @3) -> @51 @23 +@147 := @50 (@10 @15) +@151 := {t : @59} -> (h : @145) -> (xs : @5) -> @147 @79 +@152 := @143 @12 +@156 := (h : (x : @3) -> @52) -> (xs : @5) -> @147 @14 +@158 := @152 @55 @6 +@160 := @50 @11 @14 +@161 := ByteArray +@162 := LexLeanTarget.TargetSyntax.Value.bytes +@163 := @162 @21 +@164 := LexLeanTarget.TargetSyntax.Ty.bytes +@165 := @162 @15 +@171 := {p : @16} -> {c : @17} -> {A : @18} -> (b : @161) -> @24 @165 @164 +@173 := LexLeanPreservation.Rust.wt_bytes @0 +@178 := {c : @17} -> {A : @18} -> (b : @161) -> @36 @165 @164 +@179 := @173 @1 +@183 := {A : @18} -> (b : @161) -> @44 @165 @164 +@184 := @179 @2 +@187 := (b : @161) -> @50 @165 @164 +@188 := @184 @21 +@190 := @50 @163 @164 +@191 := @7 @23 +@192 := @49 @23 +@194 := @50 @191 @12 +@195 := List.nil.{0} +@196 := List.cons.{0} +@197 := @195 @57 +@198 := @196 @57 +@200 := @198 @191 @197 +@202 := @198 @163 @200 +@204 := @198 @11 @202 +@205 := Prod.{0, 0} +@206 := @205 @3 +@207 := @206 @57 +@208 := 2 +@211 := Prod.mk.{0, 0} @3 @57 +@212 := @211 @208 +@213 := @212 @191 +@215 := @211 1 +@216 := @215 @163 +@217 := 0 +@218 := @211 @217 +@219 := @218 @11 +@220 := @195 @207 +@221 := @196 @207 +@223 := @221 @219 @220 +@225 := @221 @216 @223 +@227 := @221 @213 @225 +@228 := Bool.true +@229 := LexLeanTarget.TargetSyntax.Function +@230 := LexLeanTarget.TargetSyntax.Program.functions +@231 := @230 @0 +@232 := @195 @3 +@233 := @195 @59 +@234 := LexLeanTarget.TargetSyntax.Ty.unit +@235 := LexLeanTarget.TargetSyntax.Value.unit +@238 := LexLeanTarget.TargetSyntax.Expr.value @234 @235 +@243 := LexLeanTarget.TargetSyntax.Function.mk @232 @233 @234 @238 +@248 := List.getD.{0} @229 @231 @217 @243 +@252 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd.root @15 @217 +@253 := LexLeanPreservation.Rust.WTL +@261 := {p : @16} -> {c : @17} -> {A : @18} -> @253 @21 @23 @15 @197 @233 +@263 := LexLeanPreservation.Rust.wtl_nil @0 +@264 := @253 @0 +@270 := {c : @17} -> {A : @18} -> @264 @23 @15 @197 @233 +@271 := @263 @1 +@272 := @264 @1 +@276 := {A : @18} -> @272 @15 @197 @233 +@277 := @271 @2 +@278 := @272 @2 +@279 := @278 @197 +@280 := @279 @233 +@281 := @4 @57 +@282 := @4 @59 +@284 := @65 @6 @21 +@289 := @253 @71 @60 @62 @21 @23 +@290 := #8 +@293 := @253 @290 @71 @60 +@295 := @198 @62 @6 +@296 := @293 @295 +@297 := @196 @59 +@299 := @297 @64 @21 +@309 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {v : @57} -> {t : @59} -> {vs : @281} -> {ts : @282} -> (h : @284) -> (hs : @289) -> @296 @299 +@311 := LexLeanPreservation.Rust.wtl_cons @0 +@329 := {c : @17} -> + {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @281} -> + {ts : @282} -> (h : @92 @6 @21) -> (hs : @264 @60 @62 @21 @23) -> @264 @71 @60 @295 @299 +@330 := @311 @1 +@345 := {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @281} -> {ts : @282} -> (h : @108 @6 @21) -> (hs : @272 @62 @21 @23) -> @272 @60 @295 @299 +@346 := @330 @2 +@348 := @50 @6 @21 +@350 := @278 @21 @23 +@358 := {v : @57} -> + {t : @59} -> {vs : @281} -> {ts : @282} -> (h : @348) -> (hs : @350) -> @278 @295 @299 +@359 := @346 @191 +@360 := @7 @64 +@362 := @50 @360 @21 +@363 := @7 @60 +@364 := @198 @363 +@372 := {t : @59} -> {vs : @281} -> {ts : @282} -> (h : @362) -> (hs : @350) -> @278 (@364 @6) @299 +@373 := @359 @12 +@374 := @7 @6 +@376 := @50 @374 @12 +@377 := @7 @62 +@378 := @198 @377 +@380 := @278 (@378 @6) +@381 := @297 @12 +@382 := @381 @21 +@387 := {vs : @281} -> {ts : @282} -> (h : @376) -> (hs : @350) -> @380 @382 +@388 := @373 @197 +@389 := @7 @21 +@391 := @50 @389 @12 +@392 := @279 @23 +@394 := @198 @360 @197 +@399 := {ts : @282} -> (h : @391) -> (hs : @392) -> @278 @394 @382 +@400 := @388 @233 +@402 := @198 @374 @197 +@403 := @278 @402 +@404 := @381 @233 +@407 := (h : @194) -> (hs : @280) -> @403 @404 +@408 := @400 @192 +@410 := @198 @389 @197 +@412 := @278 @410 @404 +@413 := (hs : @280) -> @412 +@414 := @408 @277 +@416 := @278 @200 @404 +@417 := @346 @163 +@418 := @162 @62 +@420 := @50 @418 @21 +@421 := @162 @71 +@422 := @198 @421 +@430 := {t : @59} -> {vs : @281} -> {ts : @282} -> (h : @420) -> (hs : @350) -> @278 (@422 @6) @299 +@431 := @417 @164 +@432 := @162 @64 +@434 := @50 @432 @164 +@435 := @162 @60 +@436 := @198 @435 +@438 := @278 (@436 @6) +@439 := @297 @164 +@440 := @439 @21 +@445 := {vs : @281} -> {ts : @282} -> (h : @434) -> (hs : @350) -> @438 @440 +@446 := @431 @200 +@447 := @162 @6 +@449 := @50 @447 @164 +@450 := @403 @23 +@452 := @198 @418 @394 +@457 := {ts : @282} -> (h : @449) -> (hs : @450) -> @278 @452 @440 +@458 := @446 @404 +@460 := @198 @432 @402 +@461 := @278 @460 +@462 := @439 @404 +@465 := (h : @190) -> (hs : @412) -> @461 @462 +@466 := @458 @188 +@468 := @198 @447 @410 +@470 := @278 @468 @462 +@471 := (hs : @416) -> @470 +@472 := @466 @414 +@474 := @278 @202 @462 +@475 := @346 @11 +@476 := @10 @60 +@478 := @50 @476 @21 +@479 := @10 @290 +@480 := @198 @479 +@488 := {t : @59} -> {vs : @281} -> {ts : @282} -> (h : @478) -> (hs : @350) -> @278 (@480 @6) @299 +@489 := @475 @14 +@490 := @10 @62 +@492 := @50 @490 @14 +@493 := @10 @71 +@494 := @198 @493 +@496 := @278 (@494 @6) +@497 := @297 @14 +@498 := @497 @21 +@503 := {vs : @281} -> {ts : @282} -> (h : @492) -> (hs : @350) -> @496 @498 +@504 := @489 @202 +@505 := @10 @64 +@507 := @50 @505 @14 +@508 := @461 @23 +@510 := @198 @476 @452 +@511 := @278 @510 +@515 := {ts : @282} -> (h : @507) -> (hs : @508) -> @511 @498 +@516 := @504 @462 +@518 := @198 @490 @460 +@519 := @278 @518 +@520 := @497 @462 +@523 := (h : @160) -> (hs : @470) -> @519 @520 +@524 := @516 @158 +@526 := @198 @505 @468 +@527 := @278 @526 +@529 := (hs : @474) -> @527 @520 +@530 := @524 @472 +@531 := @278 @204 +@532 := @531 @520 +@533 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.denote +@536 := @533 @6 @21 @23 +@537 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.__fits_0 +@540 := @537 @6 @21 @23 +@544 := Coverage.Prims.sequences @6 @21 @23 +@545 := Option.{0} +@546 := @545 @3 +@547 := UInt8 +@548 := @545 @547 +@549 := @545 @5 +@550 := @545 @161 +@551 := Bool +@553 := @205 @551 @551 +@555 := @205 @550 @553 +@557 := @205 @549 @555 +@559 := @205 @548 @557 +@561 := @205 @546 @559 +@562 := @206 @561 +@564 := @205 @161 @562 +@565 := LexLeanPreservation.encOption +@567 := @565 @3 @7 +@568 := LexLeanTarget.TargetSyntax.Value.u8 +@570 := @565 @547 @568 +@572 := @565 @5 @10 +@574 := @565 @161 @162 +@575 := LexLeanTarget.TargetSyntax.Value.bool +@576 := LexLeanPreservation.encPair +@580 := @576 @551 @551 @575 @575 +@584 := @576 @550 @553 @574 @580 +@588 := @576 @549 @555 @572 @584 +@592 := @576 @548 @557 @570 @588 +@596 := @576 @546 @559 @567 @592 +@600 := @576 @3 @561 @7 @596 +@604 := @576 @161 @562 @162 @600 +@609 := @576 @5 @564 @10 @604 @544 +@613 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.root @6 @21 @23 +@614 := Ne.{1} +@615 := LexLeanPreservation.Obs +@616 := @614 @615 +@617 := LexLeanPreservation.Rel +@620 := @616 (@617 @23 @15) +@621 := LexLeanPreservation.Obs.stuck +@624 := (f : @551) -> (v : @57) -> @620 @621 +@626 := LexLeanPreservation.Rust.rel_ne_stuck @540 +@634 := (v : @57) -> @616 (@617 (@537 @64 @6 @21) @15) @621 +@635 := @626 @609 +@639 := @616 (@617 @540 @609) @621 +@640 := @4 @207 +@641 := LexLeanPreservation.Rust.FunSem +@642 := #9 +@648 := (n : @3) -> @641 @642 @290 @71 @15 @60 +@649 := Eq.{1} +@650 := @545 @229 +@651 := @649 @650 +@658 := LexLeanRuntime.index (@4 @229) @229 (LexLeanRuntime.instIndexableList @229) +@662 := @651 (@658 (@230 @642) @60) +@663 := Option.some.{0} +@664 := @663 @229 +@665 := @664 @62 +@666 := @662 @665 +@667 := #10 +@671 := @253 @667 @642 @290 @62 +@672 := LexLeanTarget.TargetSyntax.Function.types +@673 := @672 @60 +@674 := @671 @673 +@675 := @545 @640 +@676 := @649 @675 +@677 := LexLeanTarget.TargetSemantics.bindAll +@678 := LexLeanTarget.TargetSyntax.Function.parameters +@683 := @676 (@677 (@678 @71) @60 @220) +@684 := @663 @640 +@685 := @684 @62 +@686 := @683 @685 +@687 := @545 @551 +@688 := @649 @687 +@689 := LexLeanPreservation.Rust.fnFallible +@690 := #11 +@693 := @688 (@689 @690 @642) +@694 := @663 @551 +@695 := @694 @62 +@696 := @693 @695 +@697 := LexLeanPreservation.RunConv +@698 := #13 +@702 := @697 @698 @667 @290 @62 +@704 := @616 @60 @621 +@705 := Exists.{1} +@706 := LexLeanPreservation.Rust.ROut +@707 := @705 @706 +@708 := And +@709 := LexLeanPreservation.Rust.RealizesFn +@713 := @708 (@709 @642 @290 @15) +@714 := LexLeanPreservation.Rust.RCI +@716 := @714 #15 +@717 := LexLeanPreservation.Rust.fnIdent +@718 := @717 @698 +@725 := (hne : @704) -> @707 (fun (ro : @706) => @713 (@716 @718 @690 @15)) +@740 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @229} -> + {args : @281} -> + {env : @640} -> + {F : @551} -> + {o : @615} -> + (hB : @648) -> + (hfn : @666) -> (hwt : @674) -> (hbind : @686) -> (hF : @696) -> (hA : @702) -> @725 +@742 := LexLeanPreservation.Rust.compose @0 +@743 := @641 @0 +@748 := (n : @3) -> @743 @290 @71 @15 @60 +@749 := @658 @231 +@752 := @651 (@749 @60) @665 +@756 := @264 @642 @290 @62 @673 +@757 := @697 @0 +@760 := @757 @667 @290 @62 +@774 := {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @229} -> + {args : @281} -> + {env : @640} -> + {F : @551} -> + {o : @615} -> + (hB : @748) -> + (hfn : @752) -> (hwt : @756) -> (hbind : @686) -> (hF : @696) -> (hA : @760) -> @725 +@775 := @742 @1 +@776 := @743 @1 +@780 := (n : @3) -> @776 @71 @15 @60 +@783 := @272 @290 @62 @673 +@784 := @689 @1 +@787 := @688 (@784 @642) @695 +@788 := @714 @1 +@798 := (hbind : @686) -> + (hF : @787) -> (hA : @760) -> (hne : @704) -> @707 (fun (ro : @706) => @713 (@788 @718 @690 @15)) +@808 := {A : @18} -> + {f : @3} -> + {fn : @229} -> + {args : @281} -> + {env : @640} -> {F : @551} -> {o : @615} -> (hB : @780) -> (hfn : @752) -> (hwt : @783) -> @798 +@809 := @775 @2 +@811 := @776 @2 @15 +@813 := (n : @3) -> @811 @60 +@814 := @278 @62 +@815 := @814 @673 +@824 := {f : @3} -> + {fn : @229} -> + {args : @281} -> + {env : @640} -> {F : @551} -> {o : @615} -> (hB : @813) -> (hfn : @752) -> (hwt : @815) -> @798 +@825 := @809 @217 +@827 := (n : @3) -> @811 @217 +@828 := @749 @217 +@829 := @651 @828 +@830 := @829 @665 +@831 := @784 @217 +@832 := @688 @831 +@833 := @832 @695 +@834 := @757 @217 +@836 := @834 @290 @62 +@838 := @788 (@717 @217) +@846 := (hF : @833) -> (hA : @836) -> (hne : @704) -> @707 (fun (ro : @706) => @713 (@838 @690 @15)) +@855 := {fn : @229} -> + {args : @281} -> + {env : @640} -> + {F : @551} -> {o : @615} -> (hB : @827) -> (hfn : @830) -> (hwt : @815) -> (hbind : @686) -> @846 +@856 := @825 @248 +@858 := @829 (@664 @248) +@859 := @672 @248 +@860 := @814 @859 +@862 := @677 (@678 @248) +@874 := {args : @281} -> + {env : @640} -> + {F : @551} -> + {o : @615} -> + (hB : @827) -> (hfn : @858) -> (hwt : @860) -> (hbind : @676 (@862 @60 @220) @685) -> @846 +@875 := @856 @204 +@878 := @480 (@422 (@364 @197)) +@880 := @278 @878 @859 +@889 := @198 (@10 @642) (@198 (@162 @290) (@198 (@7 @71) @197)) +@893 := @676 (@862 @889 @220) @685 +@902 := @198 (@10 @690) (@198 (@162 @667) (@198 (@7 @642) @197)) +@904 := @834 @902 @62 +@907 := @198 (@10 #14) +@909 := @198 (@162 @698) +@910 := #12 +@930 := {env : @640} -> + {F : @551} -> + {o : @615} -> + (hB : @827) -> + (hfn : @858) -> + (hwt : @880) -> + (hbind : @893) -> + (hF : @833) -> + (hA : @904) -> + (hne : @704) -> @707 (fun (ro : @706) => @713 (@838 (@907 (@909 (@198 (@7 @910) @197))) @15)) +@931 := @875 @227 +@934 := @494 (@436 (@378 @197)) +@936 := @278 @934 @859 +@950 := @676 (@862 @878 @220) (@684 (@221 (@212 @363) (@221 (@215 @421) (@221 (@218 @479) @220)))) +@959 := @198 (@10 @667) (@198 (@162 @642) (@198 (@7 @290) @197)) +@984 := {F : @551} -> + {o : @615} -> + (hB : @827) -> + (hfn : @858) -> + (hwt : @936) -> + (hbind : @950) -> + (hF : @833) -> + (hA : @834 @959 @62) -> + (hne : @704) -> + @707 + (fun (ro : @706) => @713 (@838 (@198 (@10 @698) (@198 (@162 @910) (@198 (@7 @690) @197))) @15)) +@985 := @931 @228 +@986 := @511 @859 +@1000 := @676 (@862 @934 @220) (@684 (@221 (@212 @377) (@221 (@215 @435) (@221 (@218 @493) @220)))) +@1002 := @832 (@694 @228) +@1004 := @834 @889 @62 +@1005 := @709 @228 +@1030 := {o : @615} -> + (hB : @827) -> + (hfn : @858) -> + (hwt : @986) -> + (hbind : @1000) -> + (hF : @1002) -> + (hA : @1004) -> + (hne : @704) -> + @707 + (fun (ro : @706) => + @708 (@1005 @290 @15) (@838 (@198 (@10 @910) (@198 (@162 @690) (@198 (@7 @667) @197))) @15)) +@1031 := @985 @536 +@1032 := @519 @859 +@1046 := @676 (@862 @510 @220) (@684 (@221 (@212 @360) (@221 (@215 @418) (@221 (@218 @476) @220)))) +@1047 := @834 @878 +@1050 := @533 @290 @71 @60 +@1051 := @1047 @1050 +@1054 := @533 @642 @290 @71 +@1074 := (hB : @827) -> + (hfn : @858) -> + (hwt : @1032) -> + (hbind : @1046) -> + (hF : @1002) -> + (hA : @1051) -> + (hne : @616 @1054 @621) -> + @707 (fun (ro : @706) => @708 (@1005 (@533 @690 @667 @642) @15) (@838 @902 @15)) +@1075 := @1031 @252 +@1076 := @527 @859 +@1090 := @676 (@862 @518 @220) (@684 (@221 (@212 @374) (@221 (@215 @432) (@221 (@218 @490) @220)))) +@1091 := @834 @934 +@1094 := @533 @71 @60 @62 +@1114 := (hfn : @858) -> + (hwt : @1076) -> + (hbind : @1090) -> + (hF : @1002) -> + (hA : @1091 @1094) -> + (hne : @616 @1050 @621) -> + @707 (fun (ro : @706) => @708 (@1005 (@533 @667 @642 @290) @15) (@838 @959 @15)) +@1115 := Eq.refl.{1} +@1118 := @1075 (@1115 @650 @828) +@1119 := @531 @859 +@1133 := @676 (@862 @526 @220) (@684 (@221 (@212 @389) (@221 (@215 @447) (@221 (@218 @505) @220)))) +@1134 := @834 @510 +@1137 := @533 @60 @62 @64 +@1153 := (hwt : @1119) -> + (hbind : @1133) -> + (hF : @1002) -> + (hA : @1134 @1137) -> + (hne : @616 @1094 @621) -> @707 (fun (ro : @706) => @708 (@1005 @1054 @15) (@838 @889 @15)) +@1154 := @1118 @530 +@1156 := @862 @204 @220 +@1159 := @676 @1156 (@684 @227) +@1160 := @834 @518 +@1163 := @533 @62 @64 @6 +@1178 := (hbind : @1159) -> + (hF : @1002) -> + (hA : @1160 @1163) -> + (hne : @616 @1137 @621) -> @707 (fun (ro : @706) => @708 (@1005 @1050 @15) (@838 @878 @15)) +@1181 := @1154 (@1115 @675 @1156) +@1182 := @834 @526 +@1185 := @533 @64 @6 @21 +@1199 := (hF : @1002) -> + (hA : @1182 @1185) -> + (hne : @616 @1163 @621) -> @707 (fun (ro : @706) => @708 (@1005 @1094 @15) (@838 @934 @15)) +@1202 := @1181 (@1115 @687 @831) +@1216 := (hA : @834 @204 @536) -> + (hne : @616 @1185 @621) -> @707 (fun (ro : @706) => @708 (@1005 @1137 @15) (@838 @510 @15)) +@1217 := @1202 @613 +@1228 := (hne : @616 @536 @621) -> @707 (fun (ro : @706) => @708 (@1005 @1163 @15) (@838 @518 @15)) +@1229 := @1217 @635 +@1235 := @708 (@1005 @1185 @15) (@838 @526 @15) +@1237 := @707 (fun (ro : @706) => @1235) +@1239 := @707 (fun (__e_ro : @706) => @1235) +@1240 := LexLeanPreservation.Rust.RepresentableL +@1241 := @10 @21 +@1242 := @162 @23 +@1244 := @198 @25 @197 +@1246 := @198 @1242 @1244 +@1249 := @1240 (@198 @1241 @1246) +@1250 := (__e_hrep : @1249) -> @1239 +@1251 := fun (__e_hrep : @1249) => @1229 +@1252 := (i : @3) -> @1250 +@1253 := fun (i : @3) => @1251 +@1254 := (b : @161) -> @1252 +@1255 := fun (b : @161) => @1253 +@1256 := (xs : @5) -> @1254 +@1257 := fun (xs : @5) => @1255 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R27/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R27/Compose/RustStd.lean deleted file mode 100644 index 68f76cbfa..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R27/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (s : String) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.string s)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.denote s) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.string s)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_string s) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.root s) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R27/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R27/Compose/RustStd.lex.tex new file mode 100644 index 000000000..0dd718ef8 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R27/Compose/RustStd.lex.tex @@ -0,0 +1,428 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd.root : @842 := @843 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd.flags +@3 := String +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.string +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.string +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (s : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_string @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (s : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (s : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (s : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@57 := Nat +@60 := Prod.{0, 0} @57 @50 +@61 := 0 +@65 := Prod.mk.{0, 0} @57 @50 @61 +@66 := @65 @6 +@67 := @51 @60 +@68 := @52 @60 +@70 := @68 @66 @67 +@71 := Bool.true +@72 := LexLeanTarget.TargetSyntax.Function +@73 := LexLeanTarget.TargetSyntax.Program.functions +@74 := @73 @0 +@75 := LexLeanTarget.TargetSyntax.Ty +@76 := @51 @57 +@77 := @51 @75 +@78 := LexLeanTarget.TargetSyntax.Ty.unit +@79 := LexLeanTarget.TargetSyntax.Value.unit +@82 := LexLeanTarget.TargetSyntax.Expr.value @78 @79 +@87 := LexLeanTarget.TargetSyntax.Function.mk @76 @77 @78 @82 +@92 := List.getD.{0} @72 @74 @61 @87 +@96 := fun (__e_n : @57) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd.root @17 @61 +@97 := LexLeanPreservation.Rust.WTL +@105 := {p : @8} -> {c : @9} -> {A : @10} -> @97 @14 @4 @17 @53 @77 +@107 := LexLeanPreservation.Rust.wtl_nil @0 +@108 := @97 @0 +@114 := {c : @9} -> {A : @10} -> @108 @4 @17 @53 @77 +@115 := @107 @1 +@116 := @108 @1 +@120 := {A : @10} -> @116 @17 @53 @77 +@121 := @115 @2 +@122 := @116 @2 +@123 := @122 @53 +@124 := @123 @77 +@125 := List.{0} +@126 := @125 @50 +@127 := @125 @75 +@128 := #6 +@129 := @11 @128 +@130 := #5 +@131 := @129 @130 +@132 := #4 +@135 := @131 @132 @12 @14 +@136 := #7 +@141 := @97 @136 @128 @130 @14 @4 +@142 := #8 +@145 := @97 @142 @136 @128 +@147 := @54 @130 @12 +@148 := @145 @147 +@149 := @52 @75 +@151 := @149 @132 @14 +@161 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @75} -> {vs : @126} -> {ts : @127} -> (h : @135) -> (hs : @141) -> @148 @151 +@163 := LexLeanPreservation.Rust.wtl_cons @0 +@183 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @75} -> + {vs : @126} -> + {ts : @127} -> + (h : @27 @130 @132 @12 @14) -> (hs : @108 @128 @130 @14 @4) -> @108 @136 @128 @147 @151 +@184 := @163 @1 +@200 := {A : @10} -> + {v : @50} -> + {t : @75} -> + {vs : @126} -> + {ts : @127} -> (h : @36 @132 @12 @14) -> (hs : @116 @130 @14 @4) -> @116 @128 @147 @151 +@201 := @184 @2 +@203 := @43 @12 @14 +@205 := @122 @14 @4 +@213 := {v : @50} -> + {t : @75} -> {vs : @126} -> {ts : @127} -> (h : @203) -> (hs : @205) -> @122 @147 @151 +@214 := @201 @6 +@215 := @5 @132 +@217 := @43 @215 @14 +@218 := @5 @128 +@219 := @54 @218 +@227 := {t : @75} -> {vs : @126} -> {ts : @127} -> (h : @217) -> (hs : @205) -> @122 (@219 @12) @151 +@228 := @214 @7 +@229 := @5 @12 +@231 := @43 @229 @7 +@232 := @5 @130 +@233 := @54 @232 +@235 := @122 (@233 @12) +@236 := @149 @7 +@237 := @236 @14 +@242 := {vs : @126} -> {ts : @127} -> (h : @231) -> (hs : @205) -> @235 @237 +@243 := @228 @53 +@244 := @5 @14 +@246 := @43 @244 @7 +@247 := @123 @4 +@249 := @54 @215 @53 +@250 := @122 @249 +@254 := {ts : @127} -> (h : @246) -> (hs : @247) -> @250 @237 +@255 := @243 @77 +@257 := @54 @229 @53 +@258 := @122 @257 +@259 := @236 @77 +@262 := (h : @49) -> (hs : @124) -> @258 @259 +@263 := @255 @47 +@265 := @54 @244 @53 +@266 := @122 @265 +@268 := (hs : @124) -> @266 @259 +@269 := @263 @121 +@270 := @122 @56 +@271 := @270 @259 +@272 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.denote +@273 := @272 @4 +@274 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.__fits_0 +@275 := @274 @4 +@277 := Coverage.Prims.decimals @4 +@278 := Int +@279 := Option.{0} +@280 := @279 @278 +@281 := UInt32 +@282 := @279 @281 +@283 := LexLeanTarget.TargetSyntax.Value.int +@284 := LexLeanPreservation.encOption +@286 := @284 @278 @283 +@287 := LexLeanTarget.TargetSyntax.Value.u32 +@289 := @284 @281 @287 +@295 := LexLeanPreservation.encPair @280 @282 @286 @289 @277 +@297 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.root @4 +@298 := Bool +@299 := Ne.{1} +@300 := LexLeanPreservation.Obs +@301 := @299 @300 +@302 := LexLeanPreservation.Rel +@305 := @301 (@302 @4 @17) +@306 := LexLeanPreservation.Obs.stuck +@309 := (f : @298) -> (v : @50) -> @305 @306 +@311 := LexLeanPreservation.Rust.rel_ne_stuck @275 +@317 := (v : @50) -> @301 (@302 (@274 @14) @17) @306 +@318 := @311 @295 +@322 := @301 (@302 @275 @295) @306 +@323 := @125 @60 +@324 := LexLeanPreservation.Rust.FunSem +@325 := #9 +@331 := (n : @57) -> @324 @325 @142 @136 @17 @128 +@332 := Eq.{1} +@333 := @279 @72 +@334 := @332 @333 +@341 := LexLeanRuntime.index (@125 @72) @72 (LexLeanRuntime.instIndexableList @72) +@345 := @334 (@341 (@73 @325) @128) +@346 := Option.some.{0} +@347 := @346 @72 +@348 := @347 @130 +@349 := @345 @348 +@350 := #10 +@354 := @97 @350 @325 @142 @130 +@355 := LexLeanTarget.TargetSyntax.Function.types +@356 := @355 @128 +@357 := @354 @356 +@358 := @279 @323 +@359 := @332 @358 +@360 := LexLeanTarget.TargetSemantics.bindAll +@361 := LexLeanTarget.TargetSyntax.Function.parameters +@366 := @359 (@360 (@361 @136) @128 @67) +@367 := @346 @323 +@368 := @367 @130 +@369 := @366 @368 +@370 := @279 @298 +@371 := @332 @370 +@372 := LexLeanPreservation.Rust.fnFallible +@373 := #11 +@376 := @371 (@372 @373 @325) +@377 := @346 @298 +@378 := @377 @130 +@379 := @376 @378 +@380 := LexLeanPreservation.RunConv +@381 := #13 +@385 := @380 @381 @350 @142 @130 +@387 := @301 @128 @306 +@388 := Exists.{1} +@389 := LexLeanPreservation.Rust.ROut +@390 := @388 @389 +@391 := And +@392 := LexLeanPreservation.Rust.RealizesFn +@396 := @391 (@392 @325 @142 @17) +@397 := LexLeanPreservation.Rust.RCI +@399 := @397 #15 +@400 := LexLeanPreservation.Rust.fnIdent +@401 := @400 @381 +@408 := (hne : @387) -> @390 (fun (ro : @389) => @396 (@399 @401 @373 @17)) +@423 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @323} -> + {F : @298} -> + {o : @300} -> + (hB : @331) -> + (hfn : @349) -> (hwt : @357) -> (hbind : @369) -> (hF : @379) -> (hA : @385) -> @408 +@425 := LexLeanPreservation.Rust.compose @0 +@426 := @324 @0 +@431 := (n : @57) -> @426 @142 @136 @17 @128 +@432 := @341 @74 +@435 := @334 (@432 @128) @348 +@439 := @108 @325 @142 @130 @356 +@440 := @380 @0 +@443 := @440 @350 @142 @130 +@457 := {c : @9} -> + {A : @10} -> + {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @323} -> + {F : @298} -> + {o : @300} -> + (hB : @431) -> + (hfn : @435) -> (hwt : @439) -> (hbind : @369) -> (hF : @379) -> (hA : @443) -> @408 +@458 := @425 @1 +@459 := @426 @1 +@463 := (n : @57) -> @459 @136 @17 @128 +@466 := @116 @142 @130 @356 +@467 := @372 @1 +@470 := @371 (@467 @325) @378 +@471 := @397 @1 +@481 := (hbind : @369) -> + (hF : @470) -> (hA : @443) -> (hne : @387) -> @390 (fun (ro : @389) => @396 (@471 @401 @373 @17)) +@491 := {A : @10} -> + {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @323} -> {F : @298} -> {o : @300} -> (hB : @463) -> (hfn : @435) -> (hwt : @466) -> @481 +@492 := @458 @2 +@494 := @459 @2 @17 +@496 := (n : @57) -> @494 @128 +@497 := @122 @130 +@498 := @497 @356 +@507 := {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @323} -> {F : @298} -> {o : @300} -> (hB : @496) -> (hfn : @435) -> (hwt : @498) -> @481 +@508 := @492 @61 +@510 := (n : @57) -> @494 @61 +@511 := @432 @61 +@512 := @334 @511 +@513 := @512 @348 +@514 := @467 @61 +@515 := @371 @514 +@516 := @515 @378 +@517 := @440 @61 +@519 := @517 @142 @130 +@521 := @471 (@400 @61) +@529 := (hF : @516) -> (hA : @519) -> (hne : @387) -> @390 (fun (ro : @389) => @396 (@521 @373 @17)) +@538 := {fn : @72} -> + {args : @126} -> + {env : @323} -> + {F : @298} -> {o : @300} -> (hB : @510) -> (hfn : @513) -> (hwt : @498) -> (hbind : @369) -> @529 +@539 := @508 @92 +@541 := @512 (@347 @92) +@542 := @355 @92 +@543 := @497 @542 +@545 := @360 (@361 @92) +@557 := {args : @126} -> + {env : @323} -> + {F : @298} -> + {o : @300} -> + (hB : @510) -> (hfn : @541) -> (hwt : @543) -> (hbind : @359 (@545 @128 @67) @368) -> @529 +@558 := @539 @56 +@559 := @219 @53 +@561 := @122 @559 @542 +@564 := @54 (@5 @136) @53 +@568 := @359 (@545 @564 @67) @368 +@571 := @54 (@5 @325) @53 +@592 := {env : @323} -> + {F : @298} -> + {o : @300} -> + (hB : @510) -> + (hfn : @541) -> + (hwt : @561) -> + (hbind : @568) -> + (hF : @516) -> + (hA : @517 @571 @130) -> + (hne : @387) -> @390 (fun (ro : @389) => @396 (@521 (@54 (@5 #12) @53) @17)) +@593 := @558 @70 +@594 := @233 @53 +@596 := @122 @594 @542 +@604 := @359 (@545 @559 @67) (@367 (@68 (@65 @218) @67)) +@607 := @54 (@5 @142) @53 +@626 := {F : @298} -> + {o : @300} -> + (hB : @510) -> + (hfn : @541) -> + (hwt : @596) -> + (hbind : @604) -> + (hF : @516) -> + (hA : @517 @607 @130) -> + (hne : @387) -> @390 (fun (ro : @389) => @396 (@521 (@54 (@5 @373) @53) @17)) +@627 := @593 @71 +@628 := @250 @542 +@636 := @359 (@545 @594 @67) (@367 (@68 (@65 @232) @67)) +@638 := @515 (@377 @71) +@640 := @517 @564 @130 +@641 := @392 @71 +@660 := {o : @300} -> + (hB : @510) -> + (hfn : @541) -> + (hwt : @628) -> + (hbind : @636) -> + (hF : @638) -> + (hA : @640) -> + (hne : @387) -> @390 (fun (ro : @389) => @391 (@641 @142 @17) (@521 (@54 (@5 @350) @53) @17)) +@661 := @627 @273 +@662 := @258 @542 +@670 := @359 (@545 @249 @67) (@367 (@68 (@65 @215) @67)) +@671 := @517 @559 +@672 := @272 @128 +@673 := @671 @672 +@674 := @272 @136 +@692 := (hB : @510) -> + (hfn : @541) -> + (hwt : @662) -> + (hbind : @670) -> + (hF : @638) -> + (hA : @673) -> + (hne : @301 @674 @306) -> @390 (fun (ro : @389) => @391 (@641 (@272 @325) @17) (@521 @571 @17)) +@693 := @661 @96 +@694 := @266 @542 +@702 := @359 (@545 @257 @67) (@367 (@68 (@65 @229) @67)) +@703 := @517 @594 +@704 := @272 @130 +@722 := (hfn : @541) -> + (hwt : @694) -> + (hbind : @702) -> + (hF : @638) -> + (hA : @703 @704) -> + (hne : @301 @672 @306) -> @390 (fun (ro : @389) => @391 (@641 (@272 @142) @17) (@521 @607 @17)) +@723 := Eq.refl.{1} +@726 := @693 (@723 @333 @511) +@727 := @270 @542 +@735 := @359 (@545 @265 @67) (@367 (@68 (@65 @244) @67)) +@736 := @517 @249 +@737 := @272 @132 +@753 := (hwt : @727) -> + (hbind : @735) -> + (hF : @638) -> + (hA : @736 @737) -> + (hne : @301 @704 @306) -> @390 (fun (ro : @389) => @391 (@641 @674 @17) (@521 @564 @17)) +@754 := @726 @269 +@756 := @545 @56 @67 +@759 := @359 @756 (@367 @70) +@760 := @517 @257 +@761 := @272 @12 +@776 := (hbind : @759) -> + (hF : @638) -> + (hA : @760 @761) -> + (hne : @301 @737 @306) -> @390 (fun (ro : @389) => @391 (@641 @672 @17) (@521 @559 @17)) +@779 := @754 (@723 @358 @756) +@780 := @517 @265 +@781 := @272 @14 +@795 := (hF : @638) -> + (hA : @780 @781) -> + (hne : @301 @761 @306) -> @390 (fun (ro : @389) => @391 (@641 @704 @17) (@521 @594 @17)) +@798 := @779 (@723 @370 @514) +@812 := (hA : @517 @56 @273) -> + (hne : @301 @781 @306) -> @390 (fun (ro : @389) => @391 (@641 @737 @17) (@521 @249 @17)) +@813 := @798 @297 +@824 := (hne : @301 @273 @306) -> @390 (fun (ro : @389) => @391 (@641 @761 @17) (@521 @257 @17)) +@825 := @813 @318 +@831 := @391 (@641 @781 @17) (@521 @265 @17) +@833 := @390 (fun (ro : @389) => @831) +@835 := @390 (fun (__e_ro : @389) => @831) +@839 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@840 := (__e_hrep : @839) -> @835 +@841 := fun (__e_hrep : @839) => @825 +@842 := (s : @3) -> @840 +@843 := fun (s : @3) => @841 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R28/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R28/Compose/RustStd.lean deleted file mode 100644 index f26839950..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R28/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Int) (b : Int8) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.int a), (_root_.LexLeanTarget.TargetSyntax.Value.i8 b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_int a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i8 b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R28/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R28/Compose/RustStd.lex.tex new file mode 100644 index 000000000..0895d4438 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R28/Compose/RustStd.lex.tex @@ -0,0 +1,488 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd.root : @983 := @984 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd.flags +@3 := Int +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.int +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.int +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_int @0 +@27 := @11 @0 +@29 := @27 @4 @15 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @29 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@37 := @36 @15 +@41 := {A : @10} -> (n : @3) -> @37 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := Int8 +@51 := LexLeanTarget.TargetSyntax.Value.i8 +@52 := @51 @15 +@55 := LexLeanTarget.TargetSyntax.Ty.fixed LexLeanTarget.TargetSyntax.IntKind.i8 +@56 := @51 @17 +@62 := {p : @8} -> {c : @9} -> {A : @10} -> (x : @50) -> @16 @56 @55 +@64 := LexLeanPreservation.Rust.wt_i8 @0 +@69 := {c : @9} -> {A : @10} -> (x : @50) -> @29 @56 @55 +@70 := @64 @1 +@74 := {A : @10} -> (x : @50) -> @37 @56 @55 +@75 := @70 @2 +@78 := (x : @50) -> @43 @56 @55 +@79 := @75 @15 +@81 := @43 @52 @55 +@82 := LexLeanTarget.TargetSyntax.Value +@83 := List.nil.{0} +@84 := List.cons.{0} +@85 := @83 @82 +@86 := @84 @82 +@88 := @86 @52 @85 +@90 := @86 @6 @88 +@91 := Nat +@94 := Prod.{0, 0} @91 @82 +@95 := 1 +@98 := Prod.mk.{0, 0} @91 @82 +@99 := @98 @95 +@100 := @99 @52 +@101 := 0 +@102 := @98 @101 +@103 := @102 @6 +@104 := @83 @94 +@105 := @84 @94 +@107 := @105 @103 @104 +@109 := @105 @100 @107 +@110 := Bool.false +@111 := LexLeanTarget.TargetSyntax.Function +@112 := LexLeanTarget.TargetSyntax.Program.functions +@113 := @112 @0 +@114 := LexLeanTarget.TargetSyntax.Ty +@115 := @83 @91 +@116 := @83 @114 +@117 := LexLeanTarget.TargetSyntax.Ty.unit +@118 := LexLeanTarget.TargetSyntax.Value.unit +@121 := LexLeanTarget.TargetSyntax.Expr.value @117 @118 +@126 := LexLeanTarget.TargetSyntax.Function.mk @115 @116 @117 @121 +@131 := List.getD.{0} @111 @113 @101 @126 +@135 := fun (__e_n : @91) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd.root @17 @101 +@136 := LexLeanPreservation.Rust.WTL +@144 := {p : @8} -> {c : @9} -> {A : @10} -> @136 @4 @15 @17 @85 @116 +@146 := LexLeanPreservation.Rust.wtl_nil @0 +@147 := @136 @0 +@153 := {c : @9} -> {A : @10} -> @147 @15 @17 @85 @116 +@154 := @146 @1 +@155 := @147 @1 +@159 := {A : @10} -> @155 @17 @85 @116 +@160 := @154 @2 +@161 := @155 @2 +@162 := @161 @85 +@163 := @162 @116 +@164 := List.{0} +@165 := @164 @82 +@166 := @164 @114 +@167 := #6 +@168 := @11 @167 +@169 := #5 +@170 := @168 @169 +@171 := #4 +@174 := @170 @171 @12 @4 +@175 := #7 +@180 := @136 @175 @167 @169 @4 @15 +@181 := #8 +@184 := @136 @181 @175 @167 +@186 := @86 @169 @12 +@187 := @184 @186 +@188 := @84 @114 +@190 := @188 @171 @4 +@200 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @82} -> {t : @114} -> {vs : @165} -> {ts : @166} -> (h : @174) -> (hs : @180) -> @187 @190 +@202 := LexLeanPreservation.Rust.wtl_cons @0 +@222 := {c : @9} -> + {A : @10} -> + {v : @82} -> + {t : @114} -> + {vs : @165} -> + {ts : @166} -> + (h : @27 @169 @171 @12 @4) -> (hs : @147 @167 @169 @4 @15) -> @147 @175 @167 @186 @190 +@223 := @202 @1 +@239 := {A : @10} -> + {v : @82} -> + {t : @114} -> + {vs : @165} -> + {ts : @166} -> (h : @36 @171 @12 @4) -> (hs : @155 @169 @4 @15) -> @155 @167 @186 @190 +@240 := @223 @2 +@242 := @43 @12 @4 +@244 := @161 @4 @15 +@252 := {v : @82} -> + {t : @114} -> {vs : @165} -> {ts : @166} -> (h : @242) -> (hs : @244) -> @161 @186 @190 +@253 := @240 @52 +@254 := @51 @171 +@256 := @43 @254 @4 +@257 := @51 @167 +@258 := @86 @257 +@266 := {t : @114} -> + {vs : @165} -> {ts : @166} -> (h : @256) -> (hs : @244) -> @161 (@258 @12) @190 +@267 := @253 @55 +@268 := @51 @12 +@270 := @43 @268 @55 +@271 := @51 @169 +@272 := @86 @271 +@274 := @161 (@272 @12) +@275 := @188 @55 +@276 := @275 @4 +@281 := {vs : @165} -> {ts : @166} -> (h : @270) -> (hs : @244) -> @274 @276 +@282 := @267 @85 +@283 := @51 @4 +@285 := @43 @283 @55 +@286 := @162 @15 +@288 := @86 @254 @85 +@293 := {ts : @166} -> (h : @285) -> (hs : @286) -> @161 @288 @276 +@294 := @282 @116 +@296 := @86 @268 @85 +@297 := @161 @296 +@298 := @275 @116 +@301 := (h : @81) -> (hs : @163) -> @297 @298 +@302 := @294 @79 +@304 := @86 @283 @85 +@306 := @161 @304 @298 +@307 := (hs : @163) -> @306 +@308 := @302 @160 +@310 := @161 @88 @298 +@311 := @240 @6 +@312 := @5 @169 +@314 := @43 @312 @4 +@315 := @5 @175 +@316 := @86 @315 +@324 := {t : @114} -> + {vs : @165} -> {ts : @166} -> (h : @314) -> (hs : @244) -> @161 (@316 @12) @190 +@325 := @311 @7 +@326 := @5 @171 +@328 := @43 @326 @7 +@329 := @5 @167 +@330 := @86 @329 +@332 := @161 (@330 @12) +@333 := @188 @7 +@334 := @333 @4 +@339 := {vs : @165} -> {ts : @166} -> (h : @328) -> (hs : @244) -> @332 @334 +@340 := @325 @88 +@341 := @5 @12 +@343 := @43 @341 @7 +@344 := @297 @15 +@346 := @86 @312 @288 +@347 := @161 @346 +@351 := {ts : @166} -> (h : @343) -> (hs : @344) -> @347 @334 +@352 := @340 @298 +@354 := @86 @326 @296 +@355 := @161 @354 +@356 := @333 @298 +@359 := (h : @49) -> (hs : @306) -> @355 @356 +@360 := @352 @47 +@362 := @86 @341 @304 +@363 := @161 @362 +@365 := (hs : @310) -> @363 @356 +@366 := @360 @308 +@367 := @161 @90 +@368 := @367 @356 +@369 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.denote +@371 := @369 @4 @15 +@372 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.__fits_0 +@374 := @372 @4 @15 +@377 := Coverage.Prims.formats @4 @15 +@378 := String +@379 := LexLeanTarget.TargetSyntax.Value.string +@385 := LexLeanPreservation.encPair @378 @378 @379 @379 @377 +@388 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.root @4 @15 +@389 := Bool +@390 := Ne.{1} +@391 := LexLeanPreservation.Obs +@392 := @390 @391 +@393 := LexLeanPreservation.Rel +@396 := @392 (@393 @15 @17) +@397 := LexLeanPreservation.Obs.stuck +@400 := (f : @389) -> (v : @82) -> @396 @397 +@402 := LexLeanPreservation.Rust.rel_ne_stuck @374 +@409 := (v : @82) -> @392 (@393 (@372 @12 @4) @17) @397 +@410 := @402 @385 +@414 := @392 (@393 @374 @385) @397 +@415 := @164 @94 +@416 := LexLeanPreservation.Rust.FunSem +@417 := #9 +@423 := (n : @91) -> @416 @417 @181 @175 @17 @167 +@424 := Eq.{1} +@425 := Option.{0} +@426 := @425 @111 +@427 := @424 @426 +@434 := LexLeanRuntime.index (@164 @111) @111 (LexLeanRuntime.instIndexableList @111) +@438 := @427 (@434 (@112 @417) @167) +@439 := Option.some.{0} +@440 := @439 @111 +@441 := @440 @169 +@442 := @438 @441 +@443 := #10 +@447 := @136 @443 @417 @181 @169 +@448 := LexLeanTarget.TargetSyntax.Function.types +@449 := @448 @167 +@450 := @447 @449 +@451 := @425 @415 +@452 := @424 @451 +@453 := LexLeanTarget.TargetSemantics.bindAll +@454 := LexLeanTarget.TargetSyntax.Function.parameters +@459 := @452 (@453 (@454 @175) @167 @104) +@460 := @439 @415 +@461 := @460 @169 +@462 := @459 @461 +@463 := @425 @389 +@464 := @424 @463 +@465 := LexLeanPreservation.Rust.fnFallible +@466 := #11 +@469 := @464 (@465 @466 @417) +@470 := @439 @389 +@471 := @470 @169 +@472 := @469 @471 +@473 := LexLeanPreservation.RunConv +@474 := #13 +@478 := @473 @474 @443 @181 @169 +@480 := @392 @167 @397 +@481 := Exists.{1} +@482 := LexLeanPreservation.Rust.ROut +@483 := @481 @482 +@484 := And +@485 := LexLeanPreservation.Rust.RealizesFn +@489 := @484 (@485 @417 @181 @17) +@490 := LexLeanPreservation.Rust.RCI +@492 := @490 #15 +@493 := LexLeanPreservation.Rust.fnIdent +@494 := @493 @474 +@501 := (hne : @480) -> @483 (fun (ro : @482) => @489 (@492 @494 @466 @17)) +@516 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @415} -> + {F : @389} -> + {o : @391} -> + (hB : @423) -> + (hfn : @442) -> (hwt : @450) -> (hbind : @462) -> (hF : @472) -> (hA : @478) -> @501 +@518 := LexLeanPreservation.Rust.compose @0 +@519 := @416 @0 +@524 := (n : @91) -> @519 @181 @175 @17 @167 +@525 := @434 @113 +@528 := @427 (@525 @167) @441 +@532 := @147 @417 @181 @169 @449 +@533 := @473 @0 +@536 := @533 @443 @181 @169 +@550 := {c : @9} -> + {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @415} -> + {F : @389} -> + {o : @391} -> + (hB : @524) -> + (hfn : @528) -> (hwt : @532) -> (hbind : @462) -> (hF : @472) -> (hA : @536) -> @501 +@551 := @518 @1 +@552 := @519 @1 +@556 := (n : @91) -> @552 @175 @17 @167 +@559 := @155 @181 @169 @449 +@560 := @465 @1 +@563 := @464 (@560 @417) @471 +@564 := @490 @1 +@574 := (hbind : @462) -> + (hF : @563) -> (hA : @536) -> (hne : @480) -> @483 (fun (ro : @482) => @489 (@564 @494 @466 @17)) +@584 := {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @415} -> {F : @389} -> {o : @391} -> (hB : @556) -> (hfn : @528) -> (hwt : @559) -> @574 +@585 := @551 @2 +@587 := @552 @2 @17 +@589 := (n : @91) -> @587 @167 +@590 := @161 @169 +@591 := @590 @449 +@600 := {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @415} -> {F : @389} -> {o : @391} -> (hB : @589) -> (hfn : @528) -> (hwt : @591) -> @574 +@601 := @585 @101 +@603 := (n : @91) -> @587 @101 +@604 := @525 @101 +@605 := @427 @604 +@606 := @605 @441 +@607 := @560 @101 +@608 := @464 @607 +@609 := @608 @471 +@610 := @533 @101 +@612 := @610 @181 @169 +@614 := @564 (@493 @101) +@622 := (hF : @609) -> (hA : @612) -> (hne : @480) -> @483 (fun (ro : @482) => @489 (@614 @466 @17)) +@631 := {fn : @111} -> + {args : @165} -> + {env : @415} -> + {F : @389} -> {o : @391} -> (hB : @603) -> (hfn : @606) -> (hwt : @591) -> (hbind : @462) -> @622 +@632 := @601 @131 +@634 := @605 (@440 @131) +@635 := @448 @131 +@636 := @590 @635 +@638 := @453 (@454 @131) +@650 := {args : @165} -> + {env : @415} -> + {F : @389} -> + {o : @391} -> + (hB : @603) -> (hfn : @634) -> (hwt : @636) -> (hbind : @452 (@638 @167 @104) @461) -> @622 +@651 := @632 @90 +@653 := @316 (@258 @85) +@655 := @161 @653 @635 +@661 := @86 (@5 @181) (@86 (@51 @175) @85) +@665 := @452 (@638 @661 @104) @461 +@671 := @86 (@5 @443) (@86 (@51 @417) @85) +@673 := @610 @671 @169 +@675 := @86 (@5 @474) +@676 := #12 +@695 := {env : @415} -> + {F : @389} -> + {o : @391} -> + (hB : @603) -> + (hfn : @634) -> + (hwt : @655) -> + (hbind : @665) -> + (hF : @609) -> + (hA : @673) -> + (hne : @480) -> @483 (fun (ro : @482) => @489 (@614 (@675 (@86 (@51 @676) @85)) @17)) +@696 := @651 @109 +@698 := @330 (@272 @85) +@700 := @161 @698 @635 +@711 := @452 (@638 @653 @104) (@460 (@105 (@99 @257) (@105 (@102 @315) @104))) +@717 := @86 (@5 @417) (@86 (@51 @181) @85) +@739 := {F : @389} -> + {o : @391} -> + (hB : @603) -> + (hfn : @634) -> + (hwt : @700) -> + (hbind : @711) -> + (hF : @609) -> + (hA : @610 @717 @169) -> + (hne : @480) -> @483 (fun (ro : @482) => @489 (@614 (@86 (@5 @676) (@86 (@51 @466) @85)) @17)) +@740 := @696 @110 +@741 := @347 @635 +@752 := @452 (@638 @698 @104) (@460 (@105 (@99 @271) (@105 (@102 @329) @104))) +@754 := @608 (@470 @110) +@756 := @610 @661 @169 +@757 := @485 @110 +@779 := {o : @391} -> + (hB : @603) -> + (hfn : @634) -> + (hwt : @741) -> + (hbind : @752) -> + (hF : @754) -> + (hA : @756) -> + (hne : @480) -> + @483 (fun (ro : @482) => @484 (@757 @181 @17) (@614 (@86 (@5 @466) (@86 (@51 @443) @85)) @17)) +@780 := @740 @371 +@781 := @355 @635 +@792 := @452 (@638 @346 @104) (@460 (@105 (@99 @254) (@105 (@102 @312) @104))) +@793 := @610 @653 +@795 := @369 @175 @167 +@796 := @793 @795 +@798 := @369 @181 @175 +@817 := (hB : @603) -> + (hfn : @634) -> + (hwt : @781) -> + (hbind : @792) -> + (hF : @754) -> + (hA : @796) -> + (hne : @392 @798 @397) -> + @483 (fun (ro : @482) => @484 (@757 (@369 @443 @417) @17) (@614 @671 @17)) +@818 := @780 @135 +@819 := @363 @635 +@830 := @452 (@638 @354 @104) (@460 (@105 (@99 @268) (@105 (@102 @326) @104))) +@831 := @610 @698 +@833 := @369 @167 @169 +@852 := (hfn : @634) -> + (hwt : @819) -> + (hbind : @830) -> + (hF : @754) -> + (hA : @831 @833) -> + (hne : @392 @795 @397) -> + @483 (fun (ro : @482) => @484 (@757 (@369 @417 @181) @17) (@614 @717 @17)) +@853 := Eq.refl.{1} +@856 := @818 (@853 @426 @604) +@857 := @367 @635 +@868 := @452 (@638 @362 @104) (@460 (@105 (@99 @283) (@105 (@102 @341) @104))) +@869 := @610 @346 +@871 := @369 @169 @171 +@887 := (hwt : @857) -> + (hbind : @868) -> + (hF : @754) -> + (hA : @869 @871) -> + (hne : @392 @833 @397) -> @483 (fun (ro : @482) => @484 (@757 @798 @17) (@614 @661 @17)) +@888 := @856 @366 +@890 := @638 @90 @104 +@893 := @452 @890 (@460 @109) +@894 := @610 @354 +@896 := @369 @171 @12 +@911 := (hbind : @893) -> + (hF : @754) -> + (hA : @894 @896) -> + (hne : @392 @871 @397) -> @483 (fun (ro : @482) => @484 (@757 @795 @17) (@614 @653 @17)) +@914 := @888 (@853 @451 @890) +@915 := @610 @362 +@917 := @369 @12 @4 +@931 := (hF : @754) -> + (hA : @915 @917) -> + (hne : @392 @896 @397) -> @483 (fun (ro : @482) => @484 (@757 @833 @17) (@614 @698 @17)) +@934 := @914 (@853 @463 @607) +@948 := (hA : @610 @90 @371) -> + (hne : @392 @917 @397) -> @483 (fun (ro : @482) => @484 (@757 @871 @17) (@614 @346 @17)) +@949 := @934 @388 +@960 := (hne : @392 @371 @397) -> @483 (fun (ro : @482) => @484 (@757 @896 @17) (@614 @354 @17)) +@961 := @949 @410 +@967 := @484 (@757 @917 @17) (@614 @362 @17) +@969 := @483 (fun (ro : @482) => @967) +@971 := @483 (fun (__e_ro : @482) => @967) +@972 := LexLeanPreservation.Rust.RepresentableL +@973 := @5 @15 +@975 := @86 @56 @85 +@978 := @972 (@86 @973 @975) +@979 := (__e_hrep : @978) -> @971 +@980 := fun (__e_hrep : @978) => @961 +@981 := (b : @50) -> @979 +@982 := fun (b : @50) => @980 +@983 := (a : @3) -> @981 +@984 := fun (a : @3) => @982 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R29/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R29/Compose/RustStd.lean deleted file mode 100644 index 6adf94264..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R29/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (s : String) (d : String) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.string s), (_root_.LexLeanTarget.TargetSyntax.Value.string d)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.denote s d) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.string s), (_root_.LexLeanTarget.TargetSyntax.Value.string d)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_string s) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_string d) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.root s d) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R29/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R29/Compose/RustStd.lex.tex new file mode 100644 index 000000000..1ef524e34 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R29/Compose/RustStd.lex.tex @@ -0,0 +1,490 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd.root : @966 := @967 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd.flags +@3 := String +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.string +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.string +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (s : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_string @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (s : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (s : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (s : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@63 := Nat +@64 := Prod.{0, 0} +@65 := @64 @63 +@66 := @65 @54 +@67 := 1 +@70 := Prod.mk.{0, 0} @63 @54 +@71 := @70 @67 +@72 := @71 @50 +@73 := 0 +@74 := @70 @73 +@75 := @74 @6 +@76 := @55 @66 +@77 := @56 @66 +@79 := @77 @75 @76 +@81 := @77 @72 @79 +@82 := Bool.false +@83 := LexLeanTarget.TargetSyntax.Function +@84 := LexLeanTarget.TargetSyntax.Program.functions +@85 := @84 @0 +@86 := LexLeanTarget.TargetSyntax.Ty +@87 := @55 @63 +@88 := @55 @86 +@89 := LexLeanTarget.TargetSyntax.Ty.unit +@90 := LexLeanTarget.TargetSyntax.Value.unit +@93 := LexLeanTarget.TargetSyntax.Expr.value @89 @90 +@98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 +@103 := List.getD.{0} @83 @85 @73 @98 +@107 := fun (__e_n : @63) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd.root @17 @73 +@108 := LexLeanPreservation.Rust.WTL +@116 := {p : @8} -> {c : @9} -> {A : @10} -> @108 @4 @15 @17 @57 @88 +@118 := LexLeanPreservation.Rust.wtl_nil @0 +@119 := @108 @0 +@125 := {c : @9} -> {A : @10} -> @119 @15 @17 @57 @88 +@126 := @118 @1 +@127 := @119 @1 +@131 := {A : @10} -> @127 @17 @57 @88 +@132 := @126 @2 +@133 := @127 @2 +@134 := @133 @57 +@135 := @134 @88 +@136 := List.{0} +@137 := @136 @54 +@138 := @136 @86 +@139 := #6 +@140 := @11 @139 +@141 := #5 +@142 := @140 @141 +@143 := #4 +@146 := @142 @143 @12 @4 +@147 := #7 +@152 := @108 @147 @139 @141 @4 @15 +@153 := #8 +@156 := @108 @153 @147 @139 +@158 := @58 @141 @12 +@159 := @156 @158 +@160 := @56 @86 +@162 := @160 @143 @4 +@172 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @146) -> (hs : @152) -> @159 @162 +@174 := LexLeanPreservation.Rust.wtl_cons @0 +@194 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> + (h : @27 @141 @143 @12 @4) -> (hs : @119 @139 @141 @4 @15) -> @119 @147 @139 @158 @162 +@195 := @174 @1 +@211 := {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> (h : @36 @143 @12 @4) -> (hs : @127 @141 @4 @15) -> @127 @139 @158 @162 +@212 := @195 @2 +@214 := @43 @12 @4 +@216 := @133 @4 @15 +@224 := {v : @54} -> + {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @214) -> (hs : @216) -> @133 @158 @162 +@225 := @212 @50 +@226 := @5 @143 +@227 := @43 @226 +@228 := @227 @4 +@229 := @5 @139 +@230 := @58 @229 +@232 := @133 (@230 @12) +@238 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @228) -> (hs : @216) -> @232 @162 +@239 := @225 @7 +@240 := @5 @12 +@242 := @43 @240 @7 +@243 := @5 @141 +@244 := @58 @243 +@246 := @133 (@244 @12) +@247 := @160 @7 +@248 := @247 @4 +@253 := {vs : @137} -> {ts : @138} -> (h : @242) -> (hs : @216) -> @246 @248 +@254 := @239 @57 +@255 := @134 @15 +@256 := @58 @226 +@257 := @256 @57 +@262 := {ts : @138} -> (h : @49) -> (hs : @255) -> @133 @257 @248 +@263 := @254 @88 +@264 := @58 @240 +@265 := @264 @57 +@266 := @133 @265 +@267 := @247 @88 +@270 := (h : @53) -> (hs : @135) -> @266 @267 +@271 := @263 @51 +@272 := @61 @57 +@274 := @133 @272 @267 +@275 := (hs : @135) -> @274 +@276 := @271 @132 +@278 := @133 @60 @267 +@279 := @212 @6 +@281 := @43 @243 @4 +@282 := @5 @147 +@283 := @58 @282 +@291 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @281) -> (hs : @216) -> @133 (@283 @12) @162 +@292 := @279 @7 +@298 := {vs : @137} -> {ts : @138} -> (h : @227 @7) -> (hs : @216) -> @232 @248 +@299 := @292 @60 +@300 := @266 @15 +@301 := @244 @257 +@302 := @133 @301 +@306 := {ts : @138} -> (h : @242) -> (hs : @300) -> @302 @248 +@307 := @299 @267 +@308 := @256 @265 +@309 := @133 @308 +@310 := @247 @267 +@313 := (h : @49) -> (hs : @274) -> @309 @310 +@314 := @307 @47 +@315 := @264 @272 +@316 := @133 @315 +@318 := (hs : @278) -> @316 @310 +@319 := @314 @276 +@320 := @133 @62 +@321 := @320 @310 +@322 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.denote +@324 := @322 @4 @15 +@325 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.__fits_0 +@327 := @325 @4 @15 +@330 := Coverage.Prims.text @4 @15 +@331 := ByteArray +@332 := Option.{0} +@333 := @332 @3 +@334 := Ordering +@335 := @136 @3 +@336 := @332 @335 +@337 := Bool +@338 := @65 @337 +@340 := @64 @3 @338 +@342 := @64 @336 @340 +@344 := @64 @334 @342 +@346 := @64 @333 @344 +@347 := LexLeanTarget.TargetSyntax.Value.bytes +@348 := LexLeanPreservation.encOption +@350 := @348 @3 @5 +@351 := LexLeanPreservation.encOrdering +@354 := LexLeanPreservation.encList @3 @5 +@356 := @348 @335 @354 +@357 := LexLeanTarget.TargetSyntax.Value.nat +@358 := LexLeanTarget.TargetSyntax.Value.bool +@359 := LexLeanPreservation.encPair +@363 := @359 @63 @337 @357 @358 +@367 := @359 @3 @338 @5 @363 +@371 := @359 @336 @340 @356 @367 +@375 := @359 @334 @342 @351 @371 +@379 := @359 @333 @344 @350 @375 +@384 := @359 @331 @346 @347 @379 @330 +@387 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.root @4 @15 +@388 := Ne.{1} +@389 := LexLeanPreservation.Obs +@390 := @388 @389 +@391 := LexLeanPreservation.Rel +@394 := @390 (@391 @15 @17) +@395 := LexLeanPreservation.Obs.stuck +@398 := (f : @337) -> (v : @54) -> @394 @395 +@400 := LexLeanPreservation.Rust.rel_ne_stuck @327 +@407 := (v : @54) -> @390 (@391 (@325 @12 @4) @17) @395 +@408 := @400 @384 +@412 := @390 (@391 @327 @384) @395 +@413 := @136 @66 +@414 := LexLeanPreservation.Rust.FunSem +@415 := #9 +@421 := (n : @63) -> @414 @415 @153 @147 @17 @139 +@422 := Eq.{1} +@423 := @332 @83 +@424 := @422 @423 +@431 := LexLeanRuntime.index (@136 @83) @83 (LexLeanRuntime.instIndexableList @83) +@435 := @424 (@431 (@84 @415) @139) +@436 := Option.some.{0} +@437 := @436 @83 +@438 := @437 @141 +@439 := @435 @438 +@440 := #10 +@444 := @108 @440 @415 @153 @141 +@445 := LexLeanTarget.TargetSyntax.Function.types +@446 := @445 @139 +@447 := @444 @446 +@448 := @332 @413 +@449 := @422 @448 +@450 := LexLeanTarget.TargetSemantics.bindAll +@451 := LexLeanTarget.TargetSyntax.Function.parameters +@456 := @449 (@450 (@451 @147) @139 @76) +@457 := @436 @413 +@458 := @457 @141 +@459 := @456 @458 +@460 := @332 @337 +@461 := @422 @460 +@462 := LexLeanPreservation.Rust.fnFallible +@463 := #11 +@466 := @461 (@462 @463 @415) +@467 := @436 @337 +@468 := @467 @141 +@469 := @466 @468 +@470 := LexLeanPreservation.RunConv +@471 := #13 +@475 := @470 @471 @440 @153 @141 +@477 := @390 @139 @395 +@478 := Exists.{1} +@479 := LexLeanPreservation.Rust.ROut +@480 := @478 @479 +@481 := And +@482 := LexLeanPreservation.Rust.RealizesFn +@486 := @481 (@482 @415 @153 @17) +@487 := LexLeanPreservation.Rust.RCI +@489 := @487 #15 +@490 := LexLeanPreservation.Rust.fnIdent +@491 := @490 @471 +@498 := (hne : @477) -> @480 (fun (ro : @479) => @486 (@489 @491 @463 @17)) +@513 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @413} -> + {F : @337} -> + {o : @389} -> + (hB : @421) -> + (hfn : @439) -> (hwt : @447) -> (hbind : @459) -> (hF : @469) -> (hA : @475) -> @498 +@515 := LexLeanPreservation.Rust.compose @0 +@516 := @414 @0 +@521 := (n : @63) -> @516 @153 @147 @17 @139 +@522 := @431 @85 +@525 := @424 (@522 @139) @438 +@529 := @119 @415 @153 @141 @446 +@530 := @470 @0 +@533 := @530 @440 @153 @141 +@547 := {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @413} -> + {F : @337} -> + {o : @389} -> + (hB : @521) -> + (hfn : @525) -> (hwt : @529) -> (hbind : @459) -> (hF : @469) -> (hA : @533) -> @498 +@548 := @515 @1 +@549 := @516 @1 +@553 := (n : @63) -> @549 @147 @17 @139 +@556 := @127 @153 @141 @446 +@557 := @462 @1 +@560 := @461 (@557 @415) @468 +@561 := @487 @1 +@571 := (hbind : @459) -> + (hF : @560) -> (hA : @533) -> (hne : @477) -> @480 (fun (ro : @479) => @486 (@561 @491 @463 @17)) +@581 := {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @413} -> {F : @337} -> {o : @389} -> (hB : @553) -> (hfn : @525) -> (hwt : @556) -> @571 +@582 := @548 @2 +@584 := @549 @2 @17 +@586 := (n : @63) -> @584 @139 +@587 := @133 @141 +@588 := @587 @446 +@597 := {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @413} -> {F : @337} -> {o : @389} -> (hB : @586) -> (hfn : @525) -> (hwt : @588) -> @571 +@598 := @582 @73 +@600 := (n : @63) -> @584 @73 +@601 := @522 @73 +@602 := @424 @601 +@603 := @602 @438 +@604 := @557 @73 +@605 := @461 @604 +@606 := @605 @468 +@607 := @530 @73 +@609 := @607 @153 @141 +@611 := @561 (@490 @73) +@619 := (hF : @606) -> (hA : @609) -> (hne : @477) -> @480 (fun (ro : @479) => @486 (@611 @463 @17)) +@628 := {fn : @83} -> + {args : @137} -> + {env : @413} -> + {F : @337} -> {o : @389} -> (hB : @600) -> (hfn : @603) -> (hwt : @588) -> (hbind : @459) -> @619 +@629 := @598 @103 +@631 := @602 (@437 @103) +@632 := @445 @103 +@633 := @587 @632 +@635 := @450 (@451 @103) +@647 := {args : @137} -> + {env : @413} -> + {F : @337} -> + {o : @389} -> + (hB : @600) -> (hfn : @631) -> (hwt : @633) -> (hbind : @449 (@635 @139 @76) @458) -> @619 +@648 := @629 @62 +@650 := @283 (@230 @57) +@652 := @133 @650 @632 +@654 := @58 (@5 @153) +@656 := @654 (@283 @57) +@660 := @449 (@635 @656 @76) @458 +@662 := @58 (@5 @440) +@664 := @58 (@5 @415) +@666 := @662 (@664 @57) +@668 := @607 @666 @141 +@670 := @58 (@5 @471) +@673 := @58 (@5 #12) +@690 := {env : @413} -> + {F : @337} -> + {o : @389} -> + (hB : @600) -> + (hfn : @631) -> + (hwt : @652) -> + (hbind : @660) -> + (hF : @606) -> + (hA : @668) -> (hne : @477) -> @480 (fun (ro : @479) => @486 (@611 (@670 (@673 @57)) @17)) +@691 := @648 @81 +@693 := @230 (@244 @57) +@695 := @133 @693 @632 +@706 := @449 (@635 @650 @76) (@457 (@77 (@71 @229) (@77 (@74 @282) @76))) +@708 := @664 (@654 @57) +@710 := @607 @708 @141 +@712 := @58 (@5 @463) +@728 := {F : @337} -> + {o : @389} -> + (hB : @600) -> + (hfn : @631) -> + (hwt : @695) -> + (hbind : @706) -> + (hF : @606) -> + (hA : @710) -> (hne : @477) -> @480 (fun (ro : @479) => @486 (@611 (@673 (@712 @57)) @17)) +@729 := @691 @82 +@730 := @302 @632 +@741 := @449 (@635 @693 @76) (@457 (@77 (@71 @243) (@77 (@74 @229) @76))) +@743 := @605 (@467 @82) +@745 := @607 @656 @141 +@746 := @482 @82 +@764 := {o : @389} -> + (hB : @600) -> + (hfn : @631) -> + (hwt : @730) -> + (hbind : @741) -> + (hF : @743) -> + (hA : @745) -> + (hne : @477) -> @480 (fun (ro : @479) => @481 (@746 @153 @17) (@611 (@712 (@662 @57)) @17)) +@765 := @729 @324 +@766 := @309 @632 +@777 := @449 (@635 @301 @76) (@457 (@77 (@71 @226) (@77 (@74 @243) @76))) +@778 := @607 @650 +@780 := @322 @147 @139 +@781 := @778 @780 +@783 := @322 @153 @147 +@802 := (hB : @600) -> + (hfn : @631) -> + (hwt : @766) -> + (hbind : @777) -> + (hF : @743) -> + (hA : @781) -> + (hne : @390 @783 @395) -> + @480 (fun (ro : @479) => @481 (@746 (@322 @440 @415) @17) (@611 @666 @17)) +@803 := @765 @107 +@804 := @316 @632 +@815 := @449 (@635 @308 @76) (@457 (@77 (@71 @240) (@77 (@74 @226) @76))) +@816 := @607 @693 +@818 := @322 @139 @141 +@837 := (hfn : @631) -> + (hwt : @804) -> + (hbind : @815) -> + (hF : @743) -> + (hA : @816 @818) -> + (hne : @390 @780 @395) -> + @480 (fun (ro : @479) => @481 (@746 (@322 @415 @153) @17) (@611 @708 @17)) +@838 := Eq.refl.{1} +@841 := @803 (@838 @423 @601) +@842 := @320 @632 +@853 := @449 (@635 @315 @76) (@457 (@77 (@71 @6) (@77 (@74 @240) @76))) +@854 := @607 @301 +@856 := @322 @141 @143 +@872 := (hwt : @842) -> + (hbind : @853) -> + (hF : @743) -> + (hA : @854 @856) -> + (hne : @390 @818 @395) -> @480 (fun (ro : @479) => @481 (@746 @783 @17) (@611 @656 @17)) +@873 := @841 @319 +@875 := @635 @62 @76 +@878 := @449 @875 (@457 @81) +@879 := @607 @308 +@881 := @322 @143 @12 +@896 := (hbind : @878) -> + (hF : @743) -> + (hA : @879 @881) -> + (hne : @390 @856 @395) -> @480 (fun (ro : @479) => @481 (@746 @780 @17) (@611 @650 @17)) +@899 := @873 (@838 @448 @875) +@900 := @607 @315 +@902 := @322 @12 @4 +@916 := (hF : @743) -> + (hA : @900 @902) -> + (hne : @390 @881 @395) -> @480 (fun (ro : @479) => @481 (@746 @818 @17) (@611 @693 @17)) +@919 := @899 (@838 @460 @604) +@933 := (hA : @607 @62 @324) -> + (hne : @390 @902 @395) -> @480 (fun (ro : @479) => @481 (@746 @856 @17) (@611 @301 @17)) +@934 := @919 @387 +@945 := (hne : @390 @324 @395) -> @480 (fun (ro : @479) => @481 (@746 @881 @17) (@611 @308 @17)) +@946 := @934 @408 +@952 := @481 (@746 @902 @17) (@611 @315 @17) +@954 := @480 (fun (ro : @479) => @952) +@956 := @480 (fun (__e_ro : @479) => @952) +@961 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@962 := (__e_hrep : @961) -> @956 +@963 := fun (__e_hrep : @961) => @946 +@964 := (d : @3) -> @962 +@965 := fun (d : @3) => @963 +@966 := (s : @3) -> @964 +@967 := fun (s : @3) => @965 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R3/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R3/Compose/RustStd.lean deleted file mode 100644 index 41ad6218f..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R3/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd - -/-- The rendering of the root's entry, invoked on the encoded arguments, -realizes the encoded source result when the arguments satisfy §17.12's -invariants, and refuses them with `none` otherwise. -/ -theorem root (s : (List Nat)) (t : (List Nat)) (x : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) s), ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) t), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 11) [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) s), ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) t), (_root_.LexLeanTarget.TargetSyntax.Value.nat x)] __e_ro ∧ - (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.accepts s t x → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.denote s t x)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.accepts s t x → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none) __e_ro) := - match _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd.root __e_n 11) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat) s) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat) t) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat x) _root_.LexLeanPreservation.Rust.wtl_nil))) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.entry s t x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) with - | ⟨__e_ro, __e_hr, __e_hc⟩ => ⟨__e_ro, __e_hc, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.entry_accepts s t x __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.entry_refuses s t x __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R3/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R3/Compose/RustStd.lex.tex new file mode 100644 index 000000000..97b7b992c --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R3/Compose/RustStd.lex.tex @@ -0,0 +1,617 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd.root : @1271 := @1272 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd.flags +@3 := Nat +@4 := List.{0} +@5 := @4 @3 +@6 := #3 +@7 := LexLeanTarget.TargetSyntax.Value.nat +@8 := LexLeanPreservation.encList +@9 := @8 @3 +@10 := @9 @7 +@11 := @10 @6 +@12 := LexLeanTarget.TargetSyntax.Ty.nat +@13 := LexLeanTarget.TargetSyntax.Ty.list +@14 := @13 @12 +@15 := #0 +@16 := LexLeanTarget.TargetSyntax.Program +@17 := LexLeanPreservation.Rust.RCrate +@18 := LexLeanPreservation.Rust.Flags +@19 := LexLeanPreservation.Rust.WT +@20 := @19 @6 +@21 := #2 +@22 := @20 @21 +@23 := #1 +@24 := @22 @23 +@25 := @7 @15 +@31 := {p : @16} -> {c : @17} -> {A : @18} -> (n : @3) -> @24 @25 @12 +@33 := LexLeanPreservation.Rust.wt_nat @0 +@34 := @19 @0 +@41 := {c : @17} -> {A : @18} -> (n : @3) -> @34 @21 @23 @25 @12 +@42 := @33 @1 +@43 := @34 @1 +@48 := {A : @18} -> (n : @3) -> @43 @23 @25 @12 +@49 := @42 @2 +@50 := @43 @2 +@51 := @50 @25 +@52 := @51 @12 +@53 := (n : @3) -> @52 +@55 := fun (__x : @3) => @49 @15 +@56 := Sort 1 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := (a._@._internal._hyg.#0 : @15) -> @57 +@59 := LexLeanTarget.TargetSyntax.Ty +@60 := #6 +@61 := @19 @60 +@62 := #5 +@63 := @61 @62 +@64 := #4 +@65 := @63 @64 +@66 := @21 @15 +@69 := (x : @21) -> @65 @66 @23 +@70 := @4 @6 +@71 := #7 +@74 := @19 @71 @60 @62 +@77 := @8 @64 @6 @15 +@78 := @74 @77 +@79 := @13 @21 +@88 := {p : @16} -> + {c : @17} -> + {A : @18} -> {α : @56} -> {e : @58} -> {t : @59} -> (h : @69) -> (xs : @70) -> @78 @79 +@90 := LexLeanPreservation.Rust.wt_encList @0 +@92 := @34 @62 @64 +@106 := {c : @17} -> + {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @21) -> @92 @66 @23) -> (xs : @70) -> @34 @60 @62 @77 @79 +@107 := @90 @1 +@108 := @43 @64 +@120 := {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @21) -> @108 @66 @23) -> (xs : @70) -> @43 @62 @77 @79 +@121 := @107 @2 +@123 := @50 @66 @23 +@131 := {α : @56} -> {e : @58} -> {t : @59} -> (h : (x : @21) -> @123) -> (xs : @70) -> @50 @77 @79 +@132 := @121 @3 +@142 := {e : (a._@._internal._hyg.#0 : @3) -> @57} -> + {t : @59} -> (h : (x : @3) -> @123) -> (xs : @5) -> @50 (@9 @6 @15) @79 +@143 := @132 @7 +@145 := (x : @3) -> @51 @23 +@147 := @50 (@10 @15) +@151 := {t : @59} -> (h : @145) -> (xs : @5) -> @147 @79 +@152 := @143 @12 +@156 := (h : (x : @3) -> @52) -> (xs : @5) -> @147 @14 +@157 := @152 @55 +@158 := @157 @6 +@160 := @50 @11 @14 +@161 := @10 @21 +@162 := @157 @21 +@164 := @50 @161 @14 +@165 := @7 @23 +@166 := @49 @23 +@168 := @50 @165 @12 +@169 := List.nil.{0} +@170 := List.cons.{0} +@171 := @169 @57 +@172 := @170 @57 +@174 := @172 @165 @171 +@175 := @172 @161 +@176 := @175 @174 +@177 := @172 @11 +@178 := @177 @176 +@181 := Prod.{0, 0} @3 @57 +@182 := 2 +@185 := Prod.mk.{0, 0} @3 @57 +@186 := @185 @182 +@187 := @186 @165 +@189 := @185 1 +@190 := @189 @161 +@192 := @185 0 +@193 := @192 @11 +@194 := @169 @181 +@195 := @170 @181 +@197 := @195 @193 @194 +@199 := @195 @190 @197 +@201 := @195 @187 @199 +@202 := Bool.false +@203 := LexLeanTarget.TargetSyntax.Function +@204 := LexLeanTarget.TargetSyntax.Program.functions +@205 := @204 @0 +@206 := 11 +@207 := @169 @3 +@208 := @169 @59 +@209 := LexLeanTarget.TargetSyntax.Ty.unit +@210 := LexLeanTarget.TargetSyntax.Value.unit +@213 := LexLeanTarget.TargetSyntax.Expr.value @209 @210 +@218 := LexLeanTarget.TargetSyntax.Function.mk @207 @208 @209 @213 +@223 := List.getD.{0} @203 @205 @206 @218 +@227 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd.root @15 @206 +@228 := LexLeanPreservation.Rust.WTL +@236 := {p : @16} -> {c : @17} -> {A : @18} -> @228 @21 @23 @15 @171 @208 +@238 := LexLeanPreservation.Rust.wtl_nil @0 +@239 := @228 @0 +@245 := {c : @17} -> {A : @18} -> @239 @23 @15 @171 @208 +@246 := @238 @1 +@247 := @239 @1 +@251 := {A : @18} -> @247 @15 @171 @208 +@252 := @246 @2 +@253 := @247 @2 +@254 := @253 @171 +@255 := @254 @208 +@256 := @4 @57 +@257 := @4 @59 +@259 := @65 @6 @21 +@264 := @228 @71 @60 @62 @21 @23 +@265 := #8 +@268 := @228 @265 @71 @60 +@270 := @172 @62 @6 +@271 := @268 @270 +@272 := @170 @59 +@274 := @272 @64 @21 +@284 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {v : @57} -> {t : @59} -> {vs : @256} -> {ts : @257} -> (h : @259) -> (hs : @264) -> @271 @274 +@286 := LexLeanPreservation.Rust.wtl_cons @0 +@304 := {c : @17} -> + {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @256} -> + {ts : @257} -> (h : @92 @6 @21) -> (hs : @239 @60 @62 @21 @23) -> @239 @71 @60 @270 @274 +@305 := @286 @1 +@320 := {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @256} -> {ts : @257} -> (h : @108 @6 @21) -> (hs : @247 @62 @21 @23) -> @247 @60 @270 @274 +@321 := @305 @2 +@323 := @50 @6 @21 +@325 := @253 @21 @23 +@333 := {v : @57} -> + {t : @59} -> {vs : @256} -> {ts : @257} -> (h : @323) -> (hs : @325) -> @253 @270 @274 +@334 := @321 @165 +@335 := @7 @64 +@337 := @50 @335 @21 +@338 := @7 @60 +@339 := @172 @338 +@347 := {t : @59} -> {vs : @256} -> {ts : @257} -> (h : @337) -> (hs : @325) -> @253 (@339 @6) @274 +@348 := @334 @12 +@349 := @7 @6 +@351 := @50 @349 @12 +@352 := @7 @62 +@353 := @172 @352 +@355 := @253 (@353 @6) +@356 := @272 @12 +@357 := @356 @21 +@362 := {vs : @256} -> {ts : @257} -> (h : @351) -> (hs : @325) -> @355 @357 +@363 := @348 @171 +@364 := @7 @21 +@366 := @50 @364 @12 +@367 := @254 @23 +@369 := @172 @335 @171 +@374 := {ts : @257} -> (h : @366) -> (hs : @367) -> @253 @369 @357 +@375 := @363 @208 +@377 := @172 @349 @171 +@378 := @253 @377 +@379 := @356 @208 +@382 := (h : @168) -> (hs : @255) -> @378 @379 +@383 := @375 @166 +@385 := @172 @364 @171 +@387 := @253 @385 @379 +@388 := (hs : @255) -> @387 +@389 := @383 @252 +@391 := @253 @174 @379 +@392 := @321 @161 +@393 := @10 @62 +@394 := @50 @393 +@395 := @394 @21 +@396 := @10 @71 +@397 := @172 @396 +@399 := @253 (@397 @6) +@405 := {t : @59} -> {vs : @256} -> {ts : @257} -> (h : @395) -> (hs : @325) -> @399 @274 +@406 := @392 @14 +@407 := @10 @64 +@409 := @50 @407 @14 +@410 := @10 @60 +@411 := @172 @410 +@413 := @253 (@411 @6) +@414 := @272 @14 +@415 := @414 @21 +@420 := {vs : @256} -> {ts : @257} -> (h : @409) -> (hs : @325) -> @413 @415 +@421 := @406 @174 +@422 := @378 @23 +@423 := @172 @393 +@424 := @423 @369 +@429 := {ts : @257} -> (h : @160) -> (hs : @422) -> @253 @424 @415 +@430 := @421 @379 +@431 := @172 @407 +@432 := @431 @377 +@433 := @253 @432 +@434 := @414 @379 +@437 := (h : @164) -> (hs : @387) -> @433 @434 +@438 := @430 @162 +@439 := @177 @385 +@441 := @253 @439 @434 +@442 := (hs : @391) -> @441 +@443 := @438 @389 +@445 := @253 @176 @434 +@446 := @321 @11 +@448 := @50 @410 @21 +@449 := @10 @265 +@450 := @172 @449 +@458 := {t : @59} -> {vs : @256} -> {ts : @257} -> (h : @448) -> (hs : @325) -> @253 (@450 @6) @274 +@459 := @446 @14 +@465 := {vs : @256} -> {ts : @257} -> (h : @394 @14) -> (hs : @325) -> @399 @415 +@466 := @459 @176 +@467 := @433 @23 +@468 := @411 @424 +@469 := @253 @468 +@473 := {ts : @257} -> (h : @409) -> (hs : @467) -> @469 @415 +@474 := @466 @434 +@475 := @423 @432 +@476 := @253 @475 +@477 := @414 @434 +@480 := (h : @160) -> (hs : @441) -> @476 @477 +@481 := @474 @158 +@482 := @431 @439 +@483 := @253 @482 +@485 := (hs : @445) -> @483 @477 +@486 := @481 @443 +@487 := @253 @178 +@488 := @487 @477 +@489 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.denoteEntry +@492 := @489 @6 @21 @23 +@493 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.entryFits +@496 := @493 @6 @21 @23 +@500 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.entryValue @6 @21 @23 +@504 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.entry @6 @21 @23 +@505 := Bool +@506 := Ne.{1} +@507 := LexLeanPreservation.Obs +@508 := @506 @507 +@509 := LexLeanPreservation.Rel +@512 := @508 (@509 @23 @15) +@513 := LexLeanPreservation.Obs.stuck +@516 := (f : @505) -> (v : @57) -> @512 @513 +@518 := LexLeanPreservation.Rust.rel_ne_stuck @496 +@526 := (v : @57) -> @508 (@509 (@493 @64 @6 @21) @15) @513 +@527 := @518 @500 +@531 := @508 (@509 @496 @500) @513 +@532 := @4 @181 +@533 := LexLeanPreservation.Rust.FunSem +@534 := #9 +@540 := (n : @3) -> @533 @534 @265 @71 @15 @60 +@541 := Eq.{1} +@542 := Option.{0} +@543 := @542 @203 +@544 := @541 @543 +@551 := LexLeanRuntime.index (@4 @203) @203 (LexLeanRuntime.instIndexableList @203) +@555 := @544 (@551 (@204 @534) @60) +@556 := Option.some.{0} +@557 := @556 @203 +@558 := @557 @62 +@559 := @555 @558 +@560 := #10 +@564 := @228 @560 @534 @265 @62 +@565 := LexLeanTarget.TargetSyntax.Function.types +@566 := @565 @60 +@567 := @564 @566 +@568 := @542 @532 +@569 := @541 @568 +@570 := LexLeanTarget.TargetSemantics.bindAll +@571 := LexLeanTarget.TargetSyntax.Function.parameters +@576 := @569 (@570 (@571 @71) @60 @194) +@577 := @556 @532 +@578 := @577 @62 +@579 := @576 @578 +@580 := @542 @505 +@581 := @541 @580 +@582 := LexLeanPreservation.Rust.fnFallible +@583 := #11 +@586 := @581 (@582 @583 @534) +@587 := @556 @505 +@588 := @587 @62 +@589 := @586 @588 +@590 := LexLeanPreservation.RunConv +@591 := #13 +@595 := @590 @591 @560 @265 @62 +@597 := @508 @60 @513 +@598 := Exists.{1} +@599 := LexLeanPreservation.Rust.ROut +@600 := @598 @599 +@601 := And +@602 := LexLeanPreservation.Rust.RealizesFn +@606 := @601 (@602 @534 @265 @15) +@607 := LexLeanPreservation.Rust.RCI +@609 := @607 #15 +@610 := LexLeanPreservation.Rust.fnIdent +@611 := @610 @591 +@618 := (hne : @597) -> @600 (fun (ro : @599) => @606 (@609 @611 @583 @15)) +@633 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @203} -> + {args : @256} -> + {env : @532} -> + {F : @505} -> + {o : @507} -> + (hB : @540) -> + (hfn : @559) -> (hwt : @567) -> (hbind : @579) -> (hF : @589) -> (hA : @595) -> @618 +@635 := LexLeanPreservation.Rust.compose @0 +@636 := @533 @0 +@641 := (n : @3) -> @636 @265 @71 @15 @60 +@642 := @551 @205 +@645 := @544 (@642 @60) @558 +@649 := @239 @534 @265 @62 @566 +@650 := @590 @0 +@653 := @650 @560 @265 @62 +@667 := {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @203} -> + {args : @256} -> + {env : @532} -> + {F : @505} -> + {o : @507} -> + (hB : @641) -> + (hfn : @645) -> (hwt : @649) -> (hbind : @579) -> (hF : @589) -> (hA : @653) -> @618 +@668 := @635 @1 +@669 := @636 @1 +@673 := (n : @3) -> @669 @71 @15 @60 +@676 := @247 @265 @62 @566 +@677 := @582 @1 +@680 := @581 (@677 @534) @588 +@681 := @607 @1 +@691 := (hbind : @579) -> + (hF : @680) -> (hA : @653) -> (hne : @597) -> @600 (fun (ro : @599) => @606 (@681 @611 @583 @15)) +@701 := {A : @18} -> + {f : @3} -> + {fn : @203} -> + {args : @256} -> + {env : @532} -> {F : @505} -> {o : @507} -> (hB : @673) -> (hfn : @645) -> (hwt : @676) -> @691 +@702 := @668 @2 +@704 := @669 @2 @15 +@706 := (n : @3) -> @704 @60 +@707 := @253 @62 +@708 := @707 @566 +@717 := {f : @3} -> + {fn : @203} -> + {args : @256} -> + {env : @532} -> {F : @505} -> {o : @507} -> (hB : @706) -> (hfn : @645) -> (hwt : @708) -> @691 +@718 := @702 @206 +@720 := (n : @3) -> @704 @206 +@721 := @642 @206 +@722 := @544 @721 +@723 := @722 @558 +@724 := @677 @206 +@725 := @581 @724 +@726 := @725 @588 +@727 := @650 @206 +@729 := @727 @265 @62 +@731 := @681 (@610 @206) +@739 := (hF : @726) -> (hA : @729) -> (hne : @597) -> @600 (fun (ro : @599) => @606 (@731 @583 @15)) +@748 := {fn : @203} -> + {args : @256} -> + {env : @532} -> + {F : @505} -> {o : @507} -> (hB : @720) -> (hfn : @723) -> (hwt : @708) -> (hbind : @579) -> @739 +@749 := @718 @223 +@751 := @722 (@557 @223) +@752 := @565 @223 +@753 := @707 @752 +@755 := @570 (@571 @223) +@767 := {args : @256} -> + {env : @532} -> + {F : @505} -> + {o : @507} -> + (hB : @720) -> (hfn : @751) -> (hwt : @753) -> (hbind : @569 (@755 @60 @194) @578) -> @739 +@768 := @749 @178 +@771 := @450 (@397 (@339 @171)) +@773 := @253 @771 @752 +@775 := @172 (@10 @534) +@780 := @775 (@450 (@172 (@7 @71) @171)) +@784 := @569 (@755 @780 @194) @578 +@786 := @172 (@10 @583) +@788 := @172 (@10 @560) +@793 := @786 (@788 (@172 (@7 @534) @171)) +@795 := @727 @793 @62 +@798 := @172 (@10 #14) +@800 := @172 (@10 @591) +@801 := #12 +@821 := {env : @532} -> + {F : @505} -> + {o : @507} -> + (hB : @720) -> + (hfn : @751) -> + (hwt : @773) -> + (hbind : @784) -> + (hF : @726) -> + (hA : @795) -> + (hne : @597) -> @600 (fun (ro : @599) => @606 (@731 (@798 (@800 (@172 (@7 @801) @171))) @15)) +@822 := @768 @201 +@825 := @397 (@411 (@353 @171)) +@827 := @253 @825 @752 +@841 := @569 (@755 @771 @194) (@577 (@195 (@186 @338) (@195 (@189 @396) (@195 (@192 @449) @194)))) +@846 := @788 (@775 (@172 (@7 @265) @171)) +@848 := @727 @846 @62 +@850 := @172 (@10 @801) +@869 := {F : @505} -> + {o : @507} -> + (hB : @720) -> + (hfn : @751) -> + (hwt : @827) -> + (hbind : @841) -> + (hF : @726) -> + (hA : @848) -> + (hne : @597) -> @600 (fun (ro : @599) => @606 (@731 (@800 (@850 (@172 (@7 @583) @171))) @15)) +@870 := @822 @202 +@871 := @469 @752 +@885 := @569 (@755 @825 @194) (@577 (@195 (@186 @352) (@195 (@189 @410) (@195 (@192 @396) @194)))) +@887 := @725 (@587 @202) +@889 := @727 @780 @62 +@890 := @602 @202 +@911 := {o : @507} -> + (hB : @720) -> + (hfn : @751) -> + (hwt : @871) -> + (hbind : @885) -> + (hF : @887) -> + (hA : @889) -> + (hne : @597) -> + @600 (fun (ro : @599) => @601 (@890 @265 @15) (@731 (@850 (@786 (@172 (@7 @560) @171))) @15)) +@912 := @870 @492 +@913 := @476 @752 +@927 := @569 (@755 @468 @194) (@577 (@195 (@186 @335) (@195 (@189 @393) (@195 (@192 @410) @194)))) +@928 := @727 @771 +@931 := @489 @265 @71 @60 +@932 := @928 @931 +@935 := @489 @534 @265 @71 +@955 := (hB : @720) -> + (hfn : @751) -> + (hwt : @913) -> + (hbind : @927) -> + (hF : @887) -> + (hA : @932) -> + (hne : @508 @935 @513) -> + @600 (fun (ro : @599) => @601 (@890 (@489 @583 @560 @534) @15) (@731 @793 @15)) +@956 := @912 @227 +@957 := @483 @752 +@971 := @569 (@755 @475 @194) (@577 (@195 (@186 @349) (@195 (@189 @407) (@195 (@192 @393) @194)))) +@972 := @727 @825 +@975 := @489 @71 @60 @62 +@995 := (hfn : @751) -> + (hwt : @957) -> + (hbind : @971) -> + (hF : @887) -> + (hA : @972 @975) -> + (hne : @508 @931 @513) -> + @600 (fun (ro : @599) => @601 (@890 (@489 @560 @534 @265) @15) (@731 @846 @15)) +@996 := Eq.refl.{1} +@999 := @956 (@996 @543 @721) +@1000 := @487 @752 +@1014 := @569 (@755 @482 @194) (@577 (@195 (@186 @364) (@195 (@189 @11) (@195 (@192 @407) @194)))) +@1015 := @727 @468 +@1018 := @489 @60 @62 @64 +@1034 := (hwt : @1000) -> + (hbind : @1014) -> + (hF : @887) -> + (hA : @1015 @1018) -> + (hne : @508 @975 @513) -> @600 (fun (ro : @599) => @601 (@890 @935 @15) (@731 @780 @15)) +@1035 := @999 @486 +@1037 := @755 @178 @194 +@1040 := @569 @1037 (@577 @201) +@1041 := @727 @475 +@1044 := @489 @62 @64 @6 +@1059 := (hbind : @1040) -> + (hF : @887) -> + (hA : @1041 @1044) -> + (hne : @508 @1018 @513) -> @600 (fun (ro : @599) => @601 (@890 @931 @15) (@731 @771 @15)) +@1062 := @1035 (@996 @568 @1037) +@1063 := @727 @482 +@1066 := @489 @64 @6 @21 +@1080 := (hF : @887) -> + (hA : @1063 @1066) -> + (hne : @508 @1044 @513) -> @600 (fun (ro : @599) => @601 (@890 @975 @15) (@731 @825 @15)) +@1083 := @1062 (@996 @580 @724) +@1085 := @727 @178 @492 +@1087 := @508 @1066 @513 +@1088 := @890 @1018 +@1090 := @601 (@1088 @15) +@1091 := @731 @468 +@1092 := @1091 @15 +@1097 := (hA : @1085) -> (hne : @1087) -> @600 (fun (ro : @599) => @1090 @1092) +@1098 := @1083 @504 +@1100 := @508 @492 @513 +@1101 := @890 @1044 +@1103 := @601 (@1101 @15) +@1104 := @731 @475 +@1109 := (hne : @1100) -> @600 (fun (ro : @599) => @1103 (@1104 @15)) +@1110 := @1098 @527 +@1113 := @601 (@890 @1066 @15) +@1115 := @731 @482 @15 +@1116 := @1113 @1115 +@1118 := @600 (fun (ro : @599) => @1116) +@1119 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.accepts +@1122 := @1119 @6 @21 @23 +@1123 := LexLeanPreservation.someObs +@1124 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.denote +@1128 := @1123 (@1124 @6 @21 @23) +@1131 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none +@1132 := Not +@1133 := @1132 @1122 +@1136 := @1119 @64 @6 @21 +@1140 := @1123 (@1124 @64 @6 @21) +@1141 := @1132 @1136 +@1148 := @1136 -> @890 (@1123 (@1124 @62 @64 @6)) @23 +@1149 := @890 @1131 +@1150 := @1149 @23 +@1151 := @1141 -> @1150 +@1153 := @601 @1148 @1151 +@1157 := @600 (fun (__e_ro : @599) => @601 @1115 @1153) +@1158 := fun (__e_ro : @599) => @1116 +@1159 := @1101 @23 +@1160 := @1104 @23 +@1161 := And.left +@1162 := And.right +@1165 := @1161 @1159 @1160 @15 +@1168 := @1162 @1159 @1160 @15 +@1169 := @890 @15 +@1171 := fun (__e_o : @507) => @1169 @21 +@1172 := Eq.subst.{1} +@1175 := @1119 @62 @64 @6 +@1176 := @1132 @1175 +@1181 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.entry_accepts @60 @62 @64 @15 +@1185 := @1123 (@1124 @60 @62 @64) +@1190 := @1161 (@1088 @21) (@1091 @21) @23 +@1192 := fun (__e_o : @507) => @1169 @6 +@1195 := @1172 @507 @1192 @1018 +@1199 := fun (__e_h : @1175) => @1195 @1185 @1181 @1190 +@1204 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.entry_refuses @60 @62 @64 @15 +@1208 := fun (__e_h : @1176) => @1195 @1131 @1204 @1190 +@1209 := And.intro +@1212 := @1175 -> @890 @1185 @21 +@1214 := @1176 -> @1149 @21 +@1216 := @601 @1212 @1214 +@1220 := @1209 @1212 @1214 @1199 @1208 +@1224 := @1209 @1160 @1216 @1168 @1220 +@1225 := Exists.intro.{1} +@1226 := @601 @1092 +@1229 := @1119 @60 @62 @64 +@1242 := fun (__e_ro : @599) => + @1226 (@601 (@1229 -> @890 (@1123 (@1124 @71 @60 @62)) @23) (@1132 @1229 -> @1150)) +@1246 := @1225 @599 @1242 @23 @1224 +@1248 := @601 @1159 @1160 +@1250 := fun (__e_ro : @599) => fun (__e_hand : @1116) => @1246 +@1256 := Exists.elim.{1} @599 @1158 @1157 @1110 @1250 +@1257 := LexLeanPreservation.Rust.RepresentableL +@1258 := @10 @23 +@1260 := @172 @25 @171 +@1264 := @1257 (@175 (@172 @1258 @1260)) +@1265 := (__e_hrep : @1264) -> @1157 +@1266 := fun (__e_hrep : @1264) => @1256 +@1267 := (x : @3) -> @1265 +@1268 := fun (x : @3) => @1266 +@1269 := (t : @5) -> @1267 +@1270 := fun (t : @5) => @1268 +@1271 := (s : @5) -> @1269 +@1272 := fun (s : @5) => @1270 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R30/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R30/Compose/RustStd.lean deleted file mode 100644 index dcb73ed52..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R30/Compose/RustStd.lean +++ /dev/null @@ -1,26 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd - -mutual -theorem __wt_0 : ∀ (__v : (Coverage.Syntax.Rose Nat)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.__enc_0 __v) (.adt 0) - | Coverage.Syntax.Rose.node __x0 __x1 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_list (__wtItems_0 __x1)) _root_.LexLeanPreservation.Rust.wtl_nil)) - -theorem __wtItems_0 : ∀ (__v : (List (Coverage.Syntax.Rose Nat))), _root_.LexLeanPreservation.Rust.WTAll _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.__items_0 __v) (.adt 0) - | [] => _root_.LexLeanPreservation.Rust.wtAll_nil - | __x0 :: __x1 => _root_.LexLeanPreservation.Rust.wtAll_cons (__wt_0 __x0) (__wtItems_0 __x1) - -end - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (n : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat n)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat n) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R30/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R30/Compose/RustStd.lex.tex new file mode 100644 index 000000000..b2ce89661 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R30/Compose/RustStd.lex.tex @@ -0,0 +1,637 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.__wt_0 : @689 := @688 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.__wtItems_0 : @699 := @698 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.__wtItems_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.root : @1328 := @1329 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.flags +@3 := Nat +@5 := Coverage.Syntax.Rose @3 +@6 := #0 +@7 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.__enc_0 +@8 := @7 @6 +@9 := LexLeanPreservation.Rust.WT +@10 := LexLeanTarget.TargetSyntax.Ty.adt +@11 := 0 +@12 := @10 @11 +@13 := @9 @0 +@14 := @13 @1 +@15 := @14 @2 +@17 := @15 @8 @12 +@18 := fun (__v : @5) => @17 +@19 := List.{0} +@20 := @19 @5 +@21 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.__items_0 +@22 := @21 @6 +@23 := LexLeanPreservation.Rust.WTAll +@24 := @23 @0 +@25 := @24 @1 +@26 := @25 @2 +@28 := @26 @22 @12 +@29 := fun (__v : @20) => @28 +@30 := #2 +@31 := #1 +@32 := LexLeanTarget.TargetSyntax.Value.nat +@33 := @32 @30 +@34 := LexLeanTarget.TargetSyntax.Ty.nat +@35 := LexLeanTarget.TargetSyntax.Program +@36 := LexLeanPreservation.Rust.RCrate +@37 := LexLeanPreservation.Rust.Flags +@38 := #3 +@41 := @9 @38 @30 @31 +@42 := @32 @6 +@48 := {p : @35} -> {c : @36} -> {A : @37} -> (n : @3) -> @41 @42 @34 +@50 := LexLeanPreservation.Rust.wt_nat @0 +@57 := {c : @36} -> {A : @37} -> (n : @3) -> @13 @30 @31 @42 @34 +@58 := @50 @1 +@63 := {A : @37} -> (n : @3) -> @14 @31 @42 @34 +@64 := @58 @2 +@67 := (n : @3) -> @15 @42 @34 +@68 := @64 @30 +@70 := @15 @33 @34 +@71 := LexLeanPreservation.ListEnc.enc +@72 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.__L_0 +@74 := @71 @5 @72 +@75 := @74 @31 +@76 := LexLeanTarget.TargetSyntax.Ty.list +@77 := @76 @12 +@78 := @21 @31 +@79 := LexLeanTarget.TargetSyntax.Value +@80 := @19 @79 +@81 := LexLeanTarget.TargetSyntax.Ty +@82 := #4 +@87 := @23 @82 @38 @30 @31 @6 +@88 := #5 +@91 := @9 @88 @82 @38 +@92 := LexLeanTarget.TargetSyntax.Value.list +@93 := @92 @30 +@94 := @91 @93 +@95 := @76 @31 +@102 := {p : @35} -> {c : @36} -> {A : @37} -> {vs : @80} -> {t : @81} -> (h : @87) -> @94 @95 +@104 := LexLeanPreservation.Rust.wt_list @0 +@108 := @24 @38 @30 @31 @6 +@110 := @13 @82 @38 +@117 := {c : @36} -> {A : @37} -> {vs : @80} -> {t : @81} -> (h : @108) -> @110 @93 @95 +@118 := @104 @1 +@121 := @25 @30 @31 @6 +@122 := @14 @38 +@128 := {A : @37} -> {vs : @80} -> {t : @81} -> (h : @121) -> @122 @93 @95 +@129 := @118 @2 +@136 := {vs : @80} -> {t : @81} -> (h : @26 @31 @6) -> @15 @93 @95 +@137 := @129 @78 +@138 := @21 @30 +@139 := @26 @138 +@140 := @139 @6 +@141 := @21 @38 +@146 := {t : @81} -> (h : @140) -> @15 (@92 @141) @95 +@147 := @137 @12 +@149 := @26 @78 @12 +@153 := (h : @149) -> @15 (@92 @138) @77 +@154 := @147 @6 +@157 := @15 (@92 @78) @77 +@158 := List.nil.{0} +@159 := List.cons.{0} +@160 := @158 @79 +@161 := @159 @79 +@163 := @161 @75 @160 +@164 := @161 @33 +@165 := @164 @163 +@166 := @158 @81 +@167 := @159 @81 +@168 := @167 @77 +@169 := @168 @166 +@170 := @167 @34 +@171 := @170 @169 +@172 := LexLeanPreservation.Rust.WTL +@180 := {p : @35} -> {c : @36} -> {A : @37} -> @172 @30 @31 @6 @160 @166 +@182 := LexLeanPreservation.Rust.wtl_nil @0 +@183 := @172 @0 +@189 := {c : @36} -> {A : @37} -> @183 @31 @6 @160 @166 +@190 := @182 @1 +@191 := @183 @1 +@195 := {A : @37} -> @191 @6 @160 @166 +@196 := @190 @2 +@197 := @191 @2 +@198 := @197 @160 +@199 := @198 @166 +@200 := @19 @81 +@201 := #6 +@206 := @9 @201 @88 @82 @38 @30 +@207 := #7 +@212 := @172 @207 @201 @88 @30 @31 +@213 := #8 +@216 := @172 @213 @207 @201 +@218 := @161 @88 @38 +@219 := @216 @218 +@221 := @167 @82 @30 +@231 := {p : @35} -> + {c : @36} -> + {A : @37} -> + {v : @79} -> {t : @81} -> {vs : @80} -> {ts : @200} -> (h : @206) -> (hs : @212) -> @219 @221 +@233 := LexLeanPreservation.Rust.wtl_cons @0 +@237 := @13 @88 @82 @38 @30 +@241 := @183 @201 @88 @30 @31 +@253 := {c : @36} -> + {A : @37} -> + {v : @79} -> + {t : @81} -> {vs : @80} -> {ts : @200} -> (h : @237) -> (hs : @241) -> @183 @207 @201 @218 @221 +@254 := @233 @1 +@257 := @14 @82 @38 @30 +@260 := @191 @88 @30 @31 +@270 := {A : @37} -> + {v : @79} -> + {t : @81} -> {vs : @80} -> {ts : @200} -> (h : @257) -> (hs : @260) -> @191 @201 @218 @221 +@271 := @254 @2 +@273 := @15 @38 @30 +@275 := @197 @30 @31 +@283 := {v : @79} -> + {t : @81} -> {vs : @80} -> {ts : @200} -> (h : @273) -> (hs : @275) -> @197 @218 @221 +@284 := @271 @75 +@285 := @74 @82 +@297 := {t : @81} -> + {vs : @80} -> {ts : @200} -> (h : @15 @285 @30) -> (hs : @275) -> @197 (@161 (@74 @201) @38) @221 +@298 := @284 @77 +@299 := @74 @38 +@301 := @15 @299 @77 +@305 := @197 (@161 (@74 @88) @38) +@306 := @168 @30 +@311 := {vs : @80} -> {ts : @200} -> (h : @301) -> (hs : @275) -> @305 @306 +@312 := @298 @160 +@313 := @74 @30 +@315 := @15 @313 @77 +@316 := @198 @31 +@318 := @161 @285 @160 +@323 := {ts : @200} -> (h : @315) -> (hs : @316) -> @197 @318 @306 +@324 := @312 @166 +@326 := @15 @75 @77 +@328 := @161 @299 @160 +@329 := @197 @328 +@332 := (h : @326) -> (hs : @199) -> @329 @169 +@333 := @324 @154 +@335 := @161 @313 @160 +@337 := @197 @335 @169 +@338 := (hs : @199) -> @337 +@339 := @333 @196 +@341 := @197 @163 @169 +@342 := @271 @33 +@343 := @32 @88 +@345 := @15 @343 @30 +@347 := @161 (@32 @207) +@355 := {t : @81} -> {vs : @80} -> {ts : @200} -> (h : @345) -> (hs : @275) -> @197 (@347 @38) @221 +@356 := @342 @34 +@357 := @32 @82 +@358 := @15 @357 +@359 := @358 @34 +@360 := @32 @201 +@361 := @161 @360 +@363 := @197 (@361 @38) +@364 := @170 @30 +@369 := {vs : @80} -> {ts : @200} -> (h : @359) -> (hs : @275) -> @363 @364 +@370 := @356 @163 +@371 := @32 @38 +@373 := @15 @371 @34 +@374 := @329 @31 +@375 := @161 @343 +@376 := @375 @318 +@381 := {ts : @200} -> (h : @373) -> (hs : @374) -> @197 @376 @364 +@382 := @370 @169 +@383 := @161 @357 +@384 := @383 @328 +@385 := @197 @384 +@388 := (h : @70) -> (hs : @337) -> @385 @171 +@389 := @382 @68 +@390 := @161 @371 +@391 := @390 @335 +@393 := @197 @391 @171 +@394 := (hs : @341) -> @393 +@395 := @389 @339 +@397 := @197 @165 @171 +@398 := Eq.{1} +@399 := Option.{0} +@400 := @399 @200 +@401 := @398 @400 +@402 := LexLeanPreservation.Rust.adtFields +@406 := @401 (@402 @201 @38 @30) +@407 := Option.some.{0} +@408 := @407 @200 +@409 := @408 @6 +@410 := @406 @409 +@413 := @9 @213 @207 @201 +@414 := LexLeanTarget.TargetSyntax.Value.adt +@416 := @414 @82 @38 +@417 := @413 @416 +@418 := @10 @88 +@428 := {p : @35} -> + {c : @36} -> + {A : @37} -> + {i : @3} -> {k : @3} -> {fs : @80} -> {tys : @200} -> (h : @410) -> (hf : @212) -> @417 @418 +@430 := LexLeanPreservation.Rust.wt_adt @0 +@431 := @402 @0 +@435 := @401 (@431 @38 @30) @409 +@447 := {c : @36} -> + {A : @37} -> + {i : @3} -> + {k : @3} -> {fs : @80} -> {tys : @200} -> (h : @435) -> (hf : @241) -> @13 @207 @201 @416 @418 +@448 := @430 @1 +@458 := {A : @37} -> + {i : @3} -> + {k : @3} -> {fs : @80} -> {tys : @200} -> (h : @435) -> (hf : @260) -> @14 @201 @416 @418 +@459 := @448 @2 +@460 := @15 @416 +@467 := {i : @3} -> {k : @3} -> {fs : @80} -> {tys : @200} -> (h : @435) -> (hf : @275) -> @460 @418 +@468 := @459 @11 +@469 := @431 @11 +@478 := {k : @3} -> + {fs : @80} -> {tys : @200} -> (h : @401 (@469 @30) @409) -> (hf : @275) -> @460 @12 +@479 := @468 @11 +@480 := @469 @11 +@481 := @401 @480 +@482 := @481 @409 +@483 := @414 @11 +@490 := {fs : @80} -> {tys : @200} -> (h : @482) -> (hf : @275) -> @15 (@483 @38) @12 +@491 := @479 @165 +@498 := {tys : @200} -> (h : @482) -> (hf : @385 @31) -> @15 (@483 @376) @12 +@499 := @491 @171 +@506 := (h : @481 (@408 @171)) -> (hf : @393) -> @15 (@483 @384) @12 +@507 := Eq.refl.{1} +@510 := @499 (@507 @400 @480) +@514 := (hf : @397) -> @15 (@483 @391) @12 +@515 := @510 @395 +@518 := @15 (@483 @165) @12 +@521 := fun (__x0 : @3) => fun (__x1 : @20) => fun (__ih0 : @28) => @515 +@530 := {p : @35} -> {c : @36} -> {A : @37} -> {t : @81} -> @23 @38 @30 @31 @160 @6 +@532 := LexLeanPreservation.Rust.wtAll_nil @0 +@539 := {c : @36} -> {A : @37} -> {t : @81} -> @24 @30 @31 @160 @6 +@540 := @532 @1 +@545 := {A : @37} -> {t : @81} -> @25 @31 @160 @6 +@546 := @540 @2 +@547 := @26 @160 +@549 := {t : @81} -> @547 @6 +@550 := @546 @12 +@551 := @547 @12 +@552 := @7 @38 +@554 := @91 @30 @6 +@559 := @23 @201 @88 @82 @30 @31 +@562 := @23 @207 @201 @88 +@564 := @161 @82 @38 +@574 := {p : @35} -> + {c : @36} -> + {A : @37} -> {v : @79} -> {vs : @80} -> {t : @81} -> (h : @554) -> (hs : @559) -> @562 @564 @30 +@576 := LexLeanPreservation.Rust.wtAll_cons @0 +@593 := {c : @36} -> + {A : @37} -> + {v : @79} -> + {vs : @80} -> + {t : @81} -> (h : @110 @30 @6) -> (hs : @24 @88 @82 @30 @31) -> @24 @201 @88 @564 @30 +@594 := @576 @1 +@608 := {A : @37} -> + {v : @79} -> + {vs : @80} -> {t : @81} -> (h : @122 @30 @6) -> (hs : @25 @82 @30 @31) -> @25 @88 @564 @30 +@609 := @594 @2 +@611 := @15 @30 @6 +@613 := @26 @30 @31 +@620 := {v : @79} -> {vs : @80} -> {t : @81} -> (h : @611) -> (hs : @613) -> @26 @564 @30 +@621 := @609 @552 +@622 := @7 @88 +@633 := {vs : @80} -> {t : @81} -> (h : @15 @622 @6) -> (hs : @613) -> @26 (@161 (@7 @207) @38) @30 +@634 := @621 @138 +@635 := @7 @82 +@637 := @15 @635 @6 +@638 := @21 @82 +@649 := {t : @81} -> (h : @637) -> (hs : @26 @638 @31) -> @26 (@161 (@7 @201) (@21 @88)) @30 +@650 := @634 @12 +@660 := (h : @15 @552 @12) -> (hs : @26 @141 @12) -> @26 (@161 @622 @638) @12 +@661 := @650 @31 +@667 := (hs : @139 @12) -> @26 (@161 @635 @141) @12 +@668 := @661 @6 +@672 := @26 (@161 @552 @138) @12 +@673 := fun (__ih1 : @149) => @668 +@679 := fun (__x0 : @5) => fun (__x1 : @20) => fun (__ih0 : @15 (@7 @31) @12) => @673 +@688 := fun (__v : @5) => Coverage.Syntax.Rose.rec.{0} @3 @18 @29 @521 @550 @679 @6 +@689 := (__v : @5) -> @17 +@698 := fun (__v : @20) => Coverage.Syntax.Rose.rec_1.{0} @3 @18 @29 @521 @550 @679 @6 +@699 := (__v : @20) -> @28 +@700 := @32 @31 +@701 := @64 @31 +@703 := @15 @700 @34 +@705 := @161 @700 @160 +@708 := Prod.{0, 0} @3 @79 +@712 := Prod.mk.{0, 0} @3 @79 @11 +@713 := @712 @700 +@714 := @158 @708 +@715 := @159 @708 +@717 := @715 @713 @714 +@718 := Bool.true +@719 := LexLeanTarget.TargetSyntax.Function +@720 := LexLeanTarget.TargetSyntax.Program.functions +@721 := @720 @0 +@722 := @158 @3 +@723 := LexLeanTarget.TargetSyntax.Ty.unit +@724 := LexLeanTarget.TargetSyntax.Value.unit +@727 := LexLeanTarget.TargetSyntax.Expr.value @723 @724 +@732 := LexLeanTarget.TargetSyntax.Function.mk @722 @166 @723 @727 +@737 := List.getD.{0} @719 @721 @11 @732 +@741 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.root @6 @11 +@742 := @271 @700 +@749 := {t : @81} -> {vs : @80} -> {ts : @200} -> (h : @358 @30) -> (hs : @275) -> @363 @221 +@750 := @742 @34 +@757 := {vs : @80} -> {ts : @200} -> (h : @373) -> (hs : @275) -> @197 (@375 @38) @364 +@758 := @750 @160 +@759 := @383 @160 +@760 := @197 @759 +@764 := {ts : @200} -> (h : @70) -> (hs : @316) -> @760 @364 +@765 := @758 @166 +@766 := @390 @160 +@767 := @197 @766 +@768 := @170 @166 +@771 := (h : @703) -> (hs : @199) -> @767 @768 +@772 := @765 @701 +@773 := @164 @160 +@774 := @197 @773 +@776 := (hs : @199) -> @774 @768 +@777 := @772 @196 +@778 := @197 @705 +@779 := @778 @768 +@780 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.denote +@781 := @780 @31 +@782 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.__fits_0 +@783 := @782 @31 +@786 := @32 (Coverage.RecRoots.roseTotal @31) +@788 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.root @31 +@789 := Bool +@790 := Ne.{1} +@791 := LexLeanPreservation.Obs +@792 := @790 @791 +@793 := LexLeanPreservation.Rel +@796 := @792 (@793 @31 @6) +@797 := LexLeanPreservation.Obs.stuck +@800 := (f : @789) -> (v : @79) -> @796 @797 +@802 := LexLeanPreservation.Rust.rel_ne_stuck @783 +@808 := (v : @79) -> @792 (@793 (@782 @30) @6) @797 +@809 := @802 @786 +@813 := @792 (@793 @783 @786) @797 +@814 := @19 @708 +@815 := LexLeanPreservation.Rust.FunSem +@816 := #9 +@822 := (n : @3) -> @815 @816 @213 @207 @6 @201 +@823 := @399 @719 +@824 := @398 @823 +@831 := LexLeanRuntime.index (@19 @719) @719 (LexLeanRuntime.instIndexableList @719) +@835 := @824 (@831 (@720 @816) @201) +@836 := @407 @719 +@837 := @836 @88 +@838 := @835 @837 +@839 := #10 +@843 := @172 @839 @816 @213 @88 +@844 := LexLeanTarget.TargetSyntax.Function.types +@845 := @844 @201 +@846 := @843 @845 +@847 := @399 @814 +@848 := @398 @847 +@849 := LexLeanTarget.TargetSemantics.bindAll +@850 := LexLeanTarget.TargetSyntax.Function.parameters +@855 := @848 (@849 (@850 @207) @201 @714) +@856 := @407 @814 +@857 := @856 @88 +@858 := @855 @857 +@859 := @399 @789 +@860 := @398 @859 +@861 := LexLeanPreservation.Rust.fnFallible +@862 := #11 +@865 := @860 (@861 @862 @816) +@866 := @407 @789 +@867 := @866 @88 +@868 := @865 @867 +@869 := LexLeanPreservation.RunConv +@870 := #13 +@874 := @869 @870 @839 @213 @88 +@876 := @792 @201 @797 +@877 := Exists.{1} +@878 := LexLeanPreservation.Rust.ROut +@879 := @877 @878 +@880 := And +@881 := LexLeanPreservation.Rust.RealizesFn +@885 := @880 (@881 @816 @213 @6) +@886 := LexLeanPreservation.Rust.RCI +@888 := @886 #15 +@889 := LexLeanPreservation.Rust.fnIdent +@890 := @889 @870 +@897 := (hne : @876) -> @879 (fun (ro : @878) => @885 (@888 @890 @862 @6)) +@912 := {p : @35} -> + {c : @36} -> + {A : @37} -> + {f : @3} -> + {fn : @719} -> + {args : @80} -> + {env : @814} -> + {F : @789} -> + {o : @791} -> + (hB : @822) -> + (hfn : @838) -> (hwt : @846) -> (hbind : @858) -> (hF : @868) -> (hA : @874) -> @897 +@914 := LexLeanPreservation.Rust.compose @0 +@915 := @815 @0 +@920 := (n : @3) -> @915 @213 @207 @6 @201 +@921 := @831 @721 +@924 := @824 (@921 @201) @837 +@928 := @183 @816 @213 @88 @845 +@929 := @869 @0 +@932 := @929 @839 @213 @88 +@946 := {c : @36} -> + {A : @37} -> + {f : @3} -> + {fn : @719} -> + {args : @80} -> + {env : @814} -> + {F : @789} -> + {o : @791} -> + (hB : @920) -> + (hfn : @924) -> (hwt : @928) -> (hbind : @858) -> (hF : @868) -> (hA : @932) -> @897 +@947 := @914 @1 +@948 := @915 @1 +@952 := (n : @3) -> @948 @207 @6 @201 +@955 := @191 @213 @88 @845 +@956 := @861 @1 +@959 := @860 (@956 @816) @867 +@960 := @886 @1 +@970 := (hbind : @858) -> + (hF : @959) -> (hA : @932) -> (hne : @876) -> @879 (fun (ro : @878) => @885 (@960 @890 @862 @6)) +@980 := {A : @37} -> + {f : @3} -> + {fn : @719} -> + {args : @80} -> + {env : @814} -> {F : @789} -> {o : @791} -> (hB : @952) -> (hfn : @924) -> (hwt : @955) -> @970 +@981 := @947 @2 +@983 := @948 @2 @6 +@985 := (n : @3) -> @983 @201 +@986 := @197 @88 +@987 := @986 @845 +@996 := {f : @3} -> + {fn : @719} -> + {args : @80} -> + {env : @814} -> {F : @789} -> {o : @791} -> (hB : @985) -> (hfn : @924) -> (hwt : @987) -> @970 +@997 := @981 @11 +@999 := (n : @3) -> @983 @11 +@1000 := @921 @11 +@1001 := @824 @1000 +@1002 := @1001 @837 +@1003 := @956 @11 +@1004 := @860 @1003 +@1005 := @1004 @867 +@1006 := @929 @11 +@1008 := @1006 @213 @88 +@1010 := @960 (@889 @11) +@1018 := (hF : @1005) -> + (hA : @1008) -> (hne : @876) -> @879 (fun (ro : @878) => @885 (@1010 @862 @6)) +@1027 := {fn : @719} -> + {args : @80} -> + {env : @814} -> + {F : @789} -> + {o : @791} -> (hB : @999) -> (hfn : @1002) -> (hwt : @987) -> (hbind : @858) -> @1018 +@1028 := @997 @737 +@1030 := @1001 (@836 @737) +@1031 := @844 @737 +@1032 := @986 @1031 +@1034 := @849 (@850 @737) +@1046 := {args : @80} -> + {env : @814} -> + {F : @789} -> + {o : @791} -> + (hB : @999) -> (hfn : @1030) -> (hwt : @1032) -> (hbind : @848 (@1034 @201 @714) @857) -> @1018 +@1047 := @1028 @705 +@1048 := @361 @160 +@1050 := @197 @1048 @1031 +@1051 := @347 @160 +@1055 := @848 (@1034 @1051 @714) @857 +@1058 := @161 (@32 @816) @160 +@1079 := {env : @814} -> + {F : @789} -> + {o : @791} -> + (hB : @999) -> + (hfn : @1030) -> + (hwt : @1050) -> + (hbind : @1055) -> + (hF : @1005) -> + (hA : @1006 @1058 @88) -> + (hne : @876) -> @879 (fun (ro : @878) => @885 (@1010 (@161 (@32 #12) @160) @6)) +@1080 := @1047 @717 +@1081 := @375 @160 +@1083 := @197 @1081 @1031 +@1091 := @848 (@1034 @1048 @714) (@856 (@715 (@712 @360) @714)) +@1094 := @161 (@32 @213) @160 +@1113 := {F : @789} -> + {o : @791} -> + (hB : @999) -> + (hfn : @1030) -> + (hwt : @1083) -> + (hbind : @1091) -> + (hF : @1005) -> + (hA : @1006 @1094 @88) -> + (hne : @876) -> @879 (fun (ro : @878) => @885 (@1010 (@161 (@32 @862) @160) @6)) +@1114 := @1080 @718 +@1115 := @760 @1031 +@1123 := @848 (@1034 @1081 @714) (@856 (@715 (@712 @343) @714)) +@1125 := @1004 (@866 @718) +@1127 := @1006 @1051 @88 +@1128 := @881 @718 +@1147 := {o : @791} -> + (hB : @999) -> + (hfn : @1030) -> + (hwt : @1115) -> + (hbind : @1123) -> + (hF : @1125) -> + (hA : @1127) -> + (hne : @876) -> @879 (fun (ro : @878) => @880 (@1128 @213 @6) (@1010 (@161 (@32 @839) @160) @6)) +@1148 := @1114 @781 +@1149 := @767 @1031 +@1157 := @848 (@1034 @759 @714) (@856 (@715 (@712 @357) @714)) +@1158 := @1006 @1048 +@1159 := @780 @201 +@1160 := @1158 @1159 +@1161 := @780 @207 +@1179 := (hB : @999) -> + (hfn : @1030) -> + (hwt : @1149) -> + (hbind : @1157) -> + (hF : @1125) -> + (hA : @1160) -> + (hne : @792 @1161 @797) -> @879 (fun (ro : @878) => @880 (@1128 (@780 @816) @6) (@1010 @1058 @6)) +@1180 := @1148 @741 +@1181 := @774 @1031 +@1189 := @848 (@1034 @766 @714) (@856 (@715 (@712 @371) @714)) +@1190 := @1006 @1081 +@1191 := @780 @88 +@1209 := (hfn : @1030) -> + (hwt : @1181) -> + (hbind : @1189) -> + (hF : @1125) -> + (hA : @1190 @1191) -> + (hne : @792 @1159 @797) -> @879 (fun (ro : @878) => @880 (@1128 (@780 @213) @6) (@1010 @1094 @6)) +@1212 := @1180 (@507 @823 @1000) +@1213 := @778 @1031 +@1221 := @848 (@1034 @773 @714) (@856 (@715 (@712 @33) @714)) +@1222 := @1006 @759 +@1223 := @780 @82 +@1239 := (hwt : @1213) -> + (hbind : @1221) -> + (hF : @1125) -> + (hA : @1222 @1223) -> + (hne : @792 @1191 @797) -> @879 (fun (ro : @878) => @880 (@1128 @1161 @6) (@1010 @1051 @6)) +@1240 := @1212 @777 +@1242 := @1034 @705 @714 +@1245 := @848 @1242 (@856 @717) +@1246 := @1006 @766 +@1247 := @780 @38 +@1262 := (hbind : @1245) -> + (hF : @1125) -> + (hA : @1246 @1247) -> + (hne : @792 @1223 @797) -> @879 (fun (ro : @878) => @880 (@1128 @1159 @6) (@1010 @1048 @6)) +@1265 := @1240 (@507 @847 @1242) +@1266 := @1006 @773 +@1267 := @780 @30 +@1281 := (hF : @1125) -> + (hA : @1266 @1267) -> + (hne : @792 @1247 @797) -> @879 (fun (ro : @878) => @880 (@1128 @1191 @6) (@1010 @1081 @6)) +@1284 := @1265 (@507 @859 @1003) +@1298 := (hA : @1006 @705 @781) -> + (hne : @792 @1267 @797) -> @879 (fun (ro : @878) => @880 (@1128 @1223 @6) (@1010 @759 @6)) +@1299 := @1284 @788 +@1310 := (hne : @792 @781 @797) -> @879 (fun (ro : @878) => @880 (@1128 @1247 @6) (@1010 @766 @6)) +@1311 := @1299 @809 +@1317 := @880 (@1128 @1267 @6) (@1010 @773 @6) +@1319 := @879 (fun (ro : @878) => @1317) +@1321 := @879 (fun (__e_ro : @878) => @1317) +@1325 := LexLeanPreservation.Rust.RepresentableL (@161 @42 @160) +@1326 := (__e_hrep : @1325) -> @1321 +@1327 := fun (__e_hrep : @1325) => @1311 +@1328 := (n : @3) -> @1326 +@1329 := fun (n : @3) => @1327 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R31/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R31/Compose/RustStd.lean deleted file mode 100644 index 9d2ed8990..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R31/Compose/RustStd.lean +++ /dev/null @@ -1,32 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd - -mutual -theorem __wt_0 : ∀ (__v : (Coverage.Syntax.Expr)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.__enc_0 __v) (.adt 0) - | Coverage.Syntax.Expr.literal __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - | Coverage.Syntax.Expr.plus __x0 __x1 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 __x1) _root_.LexLeanPreservation.Rust.wtl_nil)) - | Coverage.Syntax.Expr.block __x0 __x1 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_list (__wtItems_0 __x0)) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 __x1) _root_.LexLeanPreservation.Rust.wtl_nil)) - -theorem __wt_1 : ∀ (__v : (Coverage.Syntax.Stmt)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.__enc_1 __v) (.adt 1) - | Coverage.Syntax.Stmt.assign __x0 __x1 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_string __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 __x1) _root_.LexLeanPreservation.Rust.wtl_nil)) - | Coverage.Syntax.Stmt.sequence __x0 __x1 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_1 __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_1 __x1) _root_.LexLeanPreservation.Rust.wtl_nil)) - -theorem __wtItems_0 : ∀ (__v : (List (Coverage.Syntax.Stmt))), _root_.LexLeanPreservation.Rust.WTAll _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.__items_0 __v) (.adt 1) - | [] => _root_.LexLeanPreservation.Rust.wtAll_nil - | __x0 :: __x1 => _root_.LexLeanPreservation.Rust.wtAll_cons (__wt_1 __x0) (__wtItems_0 __x1) - -end - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (e : (Coverage.Syntax.Expr)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.__enc_0 e)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.denote e) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.__enc_0 e)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 e) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.root e) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R31/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R31/Compose/RustStd.lex.tex new file mode 100644 index 000000000..eb43f17a8 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R31/Compose/RustStd.lex.tex @@ -0,0 +1,885 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wt_0 : @1187 := @1186 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wt_1 : @1201 := @1200 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wtItems_0 : @1215 := @1214 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wtItems_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.root : @1800 := @1801 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.flags +@3 := Coverage.Syntax.Expr +@4 := #0 +@5 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := fun (__v : @3) => @15 +@17 := Coverage.Syntax.Stmt +@18 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.__enc_1 +@19 := @18 @4 +@20 := 1 +@21 := @8 @20 +@23 := @13 @19 @21 +@24 := fun (__v : @17) => @23 +@25 := List.{0} +@26 := @25 @17 +@27 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.__items_0 +@28 := @27 @4 +@29 := LexLeanPreservation.Rust.WTAll +@30 := @29 @0 +@31 := @30 @1 +@32 := @31 @2 +@34 := @32 @28 @21 +@35 := fun (__v : @26) => @34 +@36 := LexLeanTarget.TargetSyntax.Value.nat +@37 := @36 @4 +@38 := LexLeanTarget.TargetSyntax.Ty.nat +@39 := LexLeanTarget.TargetSyntax.Program +@40 := LexLeanPreservation.Rust.RCrate +@41 := LexLeanPreservation.Rust.Flags +@42 := Nat +@43 := #3 +@44 := @7 @43 +@45 := #2 +@46 := @44 @45 +@47 := #1 +@48 := @46 @47 +@54 := {p : @39} -> {c : @40} -> {A : @41} -> (n : @42) -> @48 @37 @38 +@56 := LexLeanPreservation.Rust.wt_nat @0 +@58 := @11 @45 @47 +@63 := {c : @40} -> {A : @41} -> (n : @42) -> @58 @37 @38 +@64 := @56 @1 +@65 := @12 @47 +@69 := {A : @41} -> (n : @42) -> @65 @37 @38 +@70 := @64 @2 +@72 := @13 @37 @38 +@73 := (n : @42) -> @72 +@74 := @70 @4 +@75 := LexLeanTarget.TargetSyntax.Value +@76 := LexLeanTarget.TargetSyntax.Ty +@77 := List.nil.{0} +@78 := List.cons.{0} +@79 := @77 @75 +@80 := @78 @75 +@82 := @80 @37 @79 +@83 := @77 @76 +@84 := @78 @76 +@85 := @84 @38 +@86 := @85 @83 +@87 := LexLeanPreservation.Rust.WTL +@95 := {p : @39} -> {c : @40} -> {A : @41} -> @87 @45 @47 @4 @79 @83 +@97 := LexLeanPreservation.Rust.wtl_nil @0 +@98 := @87 @0 +@104 := {c : @40} -> {A : @41} -> @98 @47 @4 @79 @83 +@105 := @97 @1 +@106 := @98 @1 +@110 := {A : @41} -> @106 @4 @79 @83 +@111 := @105 @2 +@112 := @106 @2 +@113 := @112 @79 +@114 := @113 @83 +@115 := @25 @75 +@116 := @25 @76 +@117 := #6 +@118 := @7 @117 +@119 := #5 +@120 := @118 @119 +@121 := #4 +@124 := @120 @121 @43 @45 +@125 := #7 +@130 := @87 @125 @117 @119 @45 @47 +@131 := #8 +@134 := @87 @131 @125 @117 +@136 := @80 @119 @43 +@137 := @134 @136 +@139 := @84 @121 @45 +@149 := {p : @39} -> + {c : @40} -> + {A : @41} -> + {v : @75} -> {t : @76} -> {vs : @115} -> {ts : @116} -> (h : @124) -> (hs : @130) -> @137 @139 +@151 := LexLeanPreservation.Rust.wtl_cons @0 +@155 := @11 @119 @121 @43 @45 +@159 := @98 @117 @119 @45 @47 +@171 := {c : @40} -> + {A : @41} -> + {v : @75} -> + {t : @76} -> {vs : @115} -> {ts : @116} -> (h : @155) -> (hs : @159) -> @98 @125 @117 @136 @139 +@172 := @151 @1 +@175 := @12 @121 @43 @45 +@178 := @106 @119 @45 @47 +@188 := {A : @41} -> + {v : @75} -> + {t : @76} -> {vs : @115} -> {ts : @116} -> (h : @175) -> (hs : @178) -> @106 @117 @136 @139 +@189 := @172 @2 +@191 := @13 @43 @45 +@193 := @112 @45 @47 +@201 := {v : @75} -> + {t : @76} -> {vs : @115} -> {ts : @116} -> (h : @191) -> (hs : @193) -> @112 @136 @139 +@202 := @189 @37 +@203 := @36 @43 +@215 := {t : @76} -> + {vs : @115} -> {ts : @116} -> (h : @13 @203 @45) -> (hs : @193) -> @112 (@80 (@36 @119) @43) @139 +@216 := @202 @38 +@217 := @36 @45 +@219 := @13 @217 @38 +@223 := @112 (@80 (@36 @121) @43) +@224 := @85 @45 +@229 := {vs : @115} -> {ts : @116} -> (h : @219) -> (hs : @193) -> @223 @224 +@230 := @216 @79 +@231 := @36 @47 +@233 := @13 @231 @38 +@234 := @113 @47 +@236 := @80 @203 @79 +@241 := {ts : @116} -> (h : @233) -> (hs : @234) -> @112 @236 @224 +@242 := @230 @83 +@244 := @80 @217 @79 +@245 := @112 @244 +@248 := (h : @72) -> (hs : @114) -> @245 @86 +@249 := @242 @74 +@251 := @80 @231 @79 +@253 := @112 @251 @86 +@254 := (hs : @114) -> @253 +@255 := @249 @111 +@257 := @112 @82 @86 +@258 := Eq.{1} +@259 := Option.{0} +@260 := @259 @116 +@261 := @258 @260 +@262 := LexLeanPreservation.Rust.adtFields +@266 := @261 (@262 @117 @43 @45) +@267 := Option.some.{0} +@268 := @267 @116 +@269 := @268 @4 +@270 := @266 @269 +@273 := @7 @131 @125 @117 +@274 := LexLeanTarget.TargetSyntax.Value.adt +@276 := @274 @121 @43 +@277 := @273 @276 +@278 := @8 @119 +@288 := {p : @39} -> + {c : @40} -> + {A : @41} -> + {i : @42} -> {k : @42} -> {fs : @115} -> {tys : @116} -> (h : @270) -> (hf : @130) -> @277 @278 +@290 := LexLeanPreservation.Rust.wt_adt @0 +@291 := @262 @0 +@295 := @261 (@291 @43 @45) @269 +@307 := {c : @40} -> + {A : @41} -> + {i : @42} -> + {k : @42} -> {fs : @115} -> {tys : @116} -> (h : @295) -> (hf : @159) -> @11 @125 @117 @276 @278 +@308 := @290 @1 +@318 := {A : @41} -> + {i : @42} -> + {k : @42} -> {fs : @115} -> {tys : @116} -> (h : @295) -> (hf : @178) -> @12 @117 @276 @278 +@319 := @308 @2 +@320 := @13 @276 +@327 := {i : @42} -> + {k : @42} -> {fs : @115} -> {tys : @116} -> (h : @295) -> (hf : @193) -> @320 @278 +@328 := @319 @9 +@329 := @291 @9 +@338 := {k : @42} -> + {fs : @115} -> {tys : @116} -> (h : @261 (@329 @45) @269) -> (hf : @193) -> @320 @10 +@339 := @328 @9 +@340 := @329 @9 +@341 := @261 @340 +@342 := @341 @269 +@343 := @274 @9 +@345 := @13 (@343 @43) +@350 := {fs : @115} -> {tys : @116} -> (h : @342) -> (hf : @193) -> @345 @10 +@351 := @339 @82 +@358 := {tys : @116} -> (h : @342) -> (hf : @245 @47) -> @13 (@343 @236) @10 +@359 := @351 @86 +@366 := (h : @341 (@268 @86)) -> (hf : @253) -> @13 (@343 @244) @10 +@367 := Eq.refl.{1} +@368 := @367 @260 +@370 := @359 (@368 @340) +@374 := (hf : @257) -> @13 (@343 @251) @10 +@375 := @370 @255 +@378 := @13 (@343 @82) @10 +@379 := fun (__x0 : @42) => @375 +@380 := @5 @43 +@381 := @5 @45 +@383 := @80 @381 @79 +@384 := @80 @380 +@385 := @384 @383 +@386 := @84 @10 +@387 := @386 @83 +@388 := @386 @387 +@389 := @189 @381 +@390 := @5 @119 +@391 := @13 @390 +@392 := @391 @45 +@394 := @80 (@5 @125) +@396 := @112 (@394 @43) +@402 := {t : @76} -> {vs : @115} -> {ts : @116} -> (h : @392) -> (hs : @193) -> @396 @139 +@403 := @389 @10 +@404 := @5 @121 +@405 := @13 @404 +@406 := @405 @10 +@407 := @5 @117 +@408 := @80 @407 +@410 := @112 (@408 @43) +@411 := @386 @45 +@416 := {vs : @115} -> {ts : @116} -> (h : @406) -> (hs : @193) -> @410 @411 +@417 := @403 @79 +@419 := @13 @380 @10 +@420 := @80 @390 +@421 := @420 @79 +@422 := @112 @421 +@426 := {ts : @116} -> (h : @419) -> (hs : @234) -> @422 @411 +@427 := @417 @83 +@429 := @13 @381 @10 +@430 := @80 @404 +@431 := @430 @79 +@432 := @112 @431 +@435 := (h : @429) -> (hs : @114) -> @432 @387 +@436 := @427 @4 +@437 := @384 @79 +@438 := @112 @437 +@439 := @438 @387 +@440 := (hs : @114) -> @439 +@441 := @436 @111 +@442 := @112 @383 +@443 := @442 @387 +@444 := @189 @380 +@446 := @13 @407 @45 +@448 := @80 (@5 @131) +@456 := {t : @76} -> {vs : @115} -> {ts : @116} -> (h : @446) -> (hs : @193) -> @112 (@448 @43) @139 +@457 := @444 @10 +@463 := {vs : @115} -> {ts : @116} -> (h : @391 @10) -> (hs : @193) -> @396 @411 +@464 := @457 @383 +@465 := @432 @47 +@466 := @408 @421 +@471 := {ts : @116} -> (h : @406) -> (hs : @465) -> @112 @466 @411 +@472 := @464 @387 +@473 := @420 @431 +@474 := @112 @473 +@477 := (h : @419) -> (hs : @439) -> @474 @388 +@478 := @472 @47 +@479 := @430 @437 +@481 := @112 @479 @388 +@482 := (hs : @443) -> @481 +@483 := @478 @441 +@485 := @112 @385 @388 +@486 := @328 @20 +@487 := @329 @20 +@488 := @261 @487 +@489 := @488 @269 +@490 := @274 @20 +@492 := @13 (@490 @43) +@497 := {fs : @115} -> {tys : @116} -> (h : @489) -> (hf : @193) -> @492 @10 +@498 := @486 @385 +@505 := {tys : @116} -> (h : @489) -> (hf : @474 @47) -> @13 (@490 @466) @10 +@506 := @498 @388 +@513 := (h : @488 (@268 @388)) -> (hf : @481) -> @13 (@490 @473) @10 +@515 := @506 (@368 @487) +@519 := (hf : @485) -> @13 (@490 @479) @10 +@520 := @515 @483 +@523 := @13 (@490 @385) @10 +@524 := @5 @47 +@526 := @13 @524 @10 +@530 := fun (__x0 : @3) => fun (__x1 : @3) => fun (__ih0 : @526) => fun (__ih1 : @526) => @520 +@531 := LexLeanPreservation.ListEnc.enc +@532 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.__L_0 +@534 := @531 @17 @532 +@535 := @534 @43 +@536 := LexLeanTarget.TargetSyntax.Ty.list +@537 := @536 @21 +@538 := @27 @43 +@543 := @29 @121 @43 @45 @47 @4 +@546 := @7 @119 @121 @43 +@547 := LexLeanTarget.TargetSyntax.Value.list +@548 := @547 @45 +@549 := @546 @548 +@550 := @536 @47 +@557 := {p : @39} -> {c : @40} -> {A : @41} -> {vs : @115} -> {t : @76} -> (h : @543) -> @549 @550 +@559 := LexLeanPreservation.Rust.wt_list @0 +@563 := @30 @43 @45 @47 @4 +@565 := @11 @121 @43 +@572 := {c : @40} -> {A : @41} -> {vs : @115} -> {t : @76} -> (h : @563) -> @565 @548 @550 +@573 := @559 @1 +@576 := @31 @45 @47 @4 +@577 := @12 @43 +@583 := {A : @41} -> {vs : @115} -> {t : @76} -> (h : @576) -> @577 @548 @550 +@584 := @573 @2 +@591 := {vs : @115} -> {t : @76} -> (h : @32 @47 @4) -> @13 @548 @550 +@592 := @584 @538 +@593 := @27 @121 +@594 := @32 @593 +@595 := @594 @4 +@596 := @27 @119 +@601 := {t : @76} -> (h : @595) -> @13 (@547 @596) @550 +@602 := @592 @21 +@604 := @32 @538 @21 +@608 := (h : @604) -> @13 (@547 @593) @537 +@609 := @602 @47 +@612 := @13 (@547 @538) @537 +@614 := @80 @535 @383 +@615 := @84 @537 +@616 := @615 @387 +@617 := @189 @535 +@618 := @534 @117 +@630 := {t : @76} -> + {vs : @115} -> {ts : @116} -> (h : @13 @618 @45) -> (hs : @193) -> @112 (@80 (@534 @131) @43) @139 +@631 := @617 @537 +@632 := @534 @119 +@634 := @13 @632 @537 +@638 := @112 (@80 (@534 @125) @43) +@639 := @615 @45 +@644 := {vs : @115} -> {ts : @116} -> (h : @634) -> (hs : @193) -> @638 @639 +@645 := @631 @383 +@646 := @534 @121 +@648 := @13 @646 @537 +@650 := @80 @618 @421 +@655 := {ts : @116} -> (h : @648) -> (hs : @465) -> @112 @650 @639 +@656 := @645 @387 +@658 := @13 @535 @537 +@660 := @80 @632 @431 +@661 := @112 @660 +@664 := (h : @658) -> (hs : @439) -> @661 @616 +@665 := @656 @609 +@667 := @80 @646 @437 +@669 := @112 @667 @616 +@670 := (hs : @443) -> @669 +@671 := @665 @441 +@673 := @112 @614 @616 +@674 := 2 +@675 := @328 @674 +@676 := @329 @674 +@677 := @261 @676 +@678 := @677 @269 +@679 := @274 @674 +@686 := {fs : @115} -> {tys : @116} -> (h : @678) -> (hf : @193) -> @13 (@679 @43) @10 +@687 := @675 @614 +@694 := {tys : @116} -> (h : @678) -> (hf : @661 @47) -> @13 (@679 @650) @10 +@695 := @687 @616 +@702 := (h : @677 (@268 @616)) -> (hf : @669) -> @13 (@679 @660) @10 +@704 := @695 (@368 @676) +@708 := (hf : @673) -> @13 (@679 @667) @10 +@709 := @704 @671 +@712 := @13 (@679 @614) @10 +@713 := fun (__ih1 : @526) => @709 +@716 := @32 (@27 @47) @21 +@719 := fun (__x0 : @26) => fun (__x1 : @3) => fun (__ih0 : @716) => @713 +@720 := LexLeanTarget.TargetSyntax.Value.string +@721 := @720 @45 +@722 := LexLeanTarget.TargetSyntax.Ty.string +@723 := String +@724 := @720 @4 +@730 := {p : @39} -> {c : @40} -> {A : @41} -> (s : @723) -> @48 @724 @722 +@732 := LexLeanPreservation.Rust.wt_string @0 +@737 := {c : @40} -> {A : @41} -> (s : @723) -> @58 @724 @722 +@738 := @732 @1 +@742 := {A : @41} -> (s : @723) -> @65 @724 @722 +@743 := @738 @2 +@746 := (s : @723) -> @13 @724 @722 +@747 := @743 @45 +@749 := @13 @721 @722 +@751 := @80 @524 @79 +@753 := @80 @721 @751 +@754 := @84 @722 +@755 := @754 @387 +@756 := @189 @524 +@763 := {t : @76} -> {vs : @115} -> {ts : @116} -> (h : @405 @45) -> (hs : @193) -> @410 @139 +@764 := @756 @10 +@771 := {vs : @115} -> {ts : @116} -> (h : @419) -> (hs : @193) -> @112 (@420 @43) @411 +@772 := @764 @79 +@776 := {ts : @116} -> (h : @429) -> (hs : @234) -> @432 @411 +@777 := @772 @83 +@778 := (h : @526) -> @440 +@779 := @777 @4 +@780 := (hs : @114) -> @443 +@781 := @779 @111 +@782 := @112 @751 +@783 := @782 @387 +@784 := @189 @721 +@785 := @720 @119 +@797 := {t : @76} -> + {vs : @115} -> {ts : @116} -> (h : @13 @785 @45) -> (hs : @193) -> @112 (@80 (@720 @125) @43) @139 +@798 := @784 @722 +@799 := @720 @121 +@801 := @13 @799 @722 +@805 := @112 (@80 (@720 @117) @43) +@806 := @754 @45 +@811 := {vs : @115} -> {ts : @116} -> (h : @801) -> (hs : @193) -> @805 @806 +@812 := @798 @751 +@813 := @720 @43 +@815 := @13 @813 @722 +@816 := @438 @47 +@818 := @80 @785 @431 +@823 := {ts : @116} -> (h : @815) -> (hs : @816) -> @112 @818 @806 +@824 := @812 @387 +@826 := @80 @799 @437 +@827 := @112 @826 +@830 := (h : @749) -> (hs : @443) -> @827 @755 +@831 := @824 @747 +@833 := @80 @813 @383 +@835 := @112 @833 @755 +@836 := (hs : @783) -> @835 +@837 := @831 @781 +@839 := @112 @753 @755 +@840 := @319 @20 +@841 := @291 @20 +@850 := {k : @42} -> + {fs : @115} -> {tys : @116} -> (h : @261 (@841 @45) @269) -> (hf : @193) -> @320 @21 +@851 := @840 @9 +@852 := @841 @9 +@853 := @261 @852 +@854 := @853 @269 +@859 := {fs : @115} -> {tys : @116} -> (h : @854) -> (hf : @193) -> @345 @21 +@860 := @851 @753 +@867 := {tys : @116} -> (h : @854) -> (hf : @827 @47) -> @13 (@343 @818) @21 +@868 := @860 @755 +@875 := (h : @853 (@268 @755)) -> (hf : @835) -> @13 (@343 @826) @21 +@877 := @868 (@368 @852) +@881 := (hf : @839) -> @13 (@343 @833) @21 +@882 := @877 @837 +@885 := @13 (@343 @753) @21 +@888 := fun (__x0 : @723) => fun (__x1 : @3) => fun (__ih0 : @15) => @882 +@889 := @18 @43 +@890 := @18 @45 +@892 := @80 @890 @79 +@893 := @80 @889 +@894 := @893 @892 +@895 := @84 @21 +@896 := @895 @83 +@897 := @895 @896 +@898 := @189 @890 +@899 := @18 @119 +@900 := @13 @899 +@901 := @900 @45 +@904 := @80 (@18 @125) @43 +@905 := @112 @904 +@911 := {t : @76} -> {vs : @115} -> {ts : @116} -> (h : @901) -> (hs : @193) -> @905 @139 +@912 := @898 @21 +@913 := @18 @121 +@914 := @13 @913 +@915 := @914 @21 +@916 := @18 @117 +@917 := @80 @916 +@919 := @112 (@917 @43) +@920 := @895 @45 +@925 := {vs : @115} -> {ts : @116} -> (h : @915) -> (hs : @193) -> @919 @920 +@926 := @912 @79 +@928 := @13 @889 @21 +@929 := @80 @899 +@930 := @929 @79 +@935 := {ts : @116} -> (h : @928) -> (hs : @234) -> @112 @930 @920 +@936 := @926 @83 +@938 := @13 @890 @21 +@939 := @80 @913 +@940 := @939 @79 +@941 := @112 @940 +@944 := (h : @938) -> (hs : @114) -> @941 @896 +@945 := @936 @4 +@946 := @893 @79 +@948 := @112 @946 @896 +@949 := (hs : @114) -> @948 +@950 := @945 @111 +@952 := @112 @892 @896 +@953 := @189 @889 +@965 := {t : @76} -> + {vs : @115} -> {ts : @116} -> (h : @13 @916 @45) -> (hs : @193) -> @112 (@80 (@18 @131) @43) @139 +@966 := @953 @21 +@972 := {vs : @115} -> {ts : @116} -> (h : @900 @21) -> (hs : @193) -> @905 @920 +@973 := @966 @892 +@974 := @941 @47 +@975 := @917 @930 +@980 := {ts : @116} -> (h : @915) -> (hs : @974) -> @112 @975 @920 +@981 := @973 @896 +@982 := @929 @940 +@983 := @112 @982 +@986 := (h : @928) -> (hs : @948) -> @983 @897 +@987 := @981 @47 +@988 := @939 @946 +@990 := @112 @988 @897 +@991 := (hs : @952) -> @990 +@992 := @987 @950 +@994 := @112 @894 @897 +@995 := @840 @20 +@996 := @841 @20 +@997 := @261 @996 +@998 := @997 @269 +@1003 := {fs : @115} -> {tys : @116} -> (h : @998) -> (hf : @193) -> @492 @21 +@1004 := @995 @894 +@1011 := {tys : @116} -> (h : @998) -> (hf : @983 @47) -> @13 (@490 @975) @21 +@1012 := @1004 @897 +@1019 := (h : @997 (@268 @897)) -> (hf : @990) -> @13 (@490 @982) @21 +@1021 := @1012 (@368 @996) +@1025 := (hf : @994) -> @13 (@490 @988) @21 +@1026 := @1021 @992 +@1029 := @13 (@490 @894) @21 +@1032 := @13 (@18 @47) @21 +@1036 := fun (__x0 : @17) => fun (__x1 : @17) => fun (__ih0 : @1032) => fun (__ih1 : @1032) => @1026 +@1045 := {p : @39} -> {c : @40} -> {A : @41} -> {t : @76} -> @29 @43 @45 @47 @79 @4 +@1047 := LexLeanPreservation.Rust.wtAll_nil @0 +@1054 := {c : @40} -> {A : @41} -> {t : @76} -> @30 @45 @47 @79 @4 +@1055 := @1047 @1 +@1060 := {A : @41} -> {t : @76} -> @31 @47 @79 @4 +@1061 := @1055 @2 +@1062 := @32 @79 +@1064 := {t : @76} -> @1062 @4 +@1065 := @1061 @21 +@1066 := @1062 @21 +@1067 := @27 @45 +@1069 := @546 @45 @4 +@1074 := @29 @117 @119 @121 @45 @47 +@1077 := @29 @125 @117 @119 +@1079 := @80 @121 @43 +@1089 := {p : @39} -> + {c : @40} -> + {A : @41} -> + {v : @75} -> {vs : @115} -> {t : @76} -> (h : @1069) -> (hs : @1074) -> @1077 @1079 @45 +@1091 := LexLeanPreservation.Rust.wtAll_cons @0 +@1108 := {c : @40} -> + {A : @41} -> + {v : @75} -> + {vs : @115} -> + {t : @76} -> (h : @565 @45 @4) -> (hs : @30 @119 @121 @45 @47) -> @30 @117 @119 @1079 @45 +@1109 := @1091 @1 +@1123 := {A : @41} -> + {v : @75} -> + {vs : @115} -> {t : @76} -> (h : @577 @45 @4) -> (hs : @31 @121 @45 @47) -> @31 @119 @1079 @45 +@1124 := @1109 @2 +@1126 := @13 @45 @4 +@1128 := @32 @45 @47 +@1135 := {v : @75} -> {vs : @115} -> {t : @76} -> (h : @1126) -> (hs : @1128) -> @32 @1079 @45 +@1136 := @1124 @889 +@1143 := {vs : @115} -> {t : @76} -> (h : @900 @4) -> (hs : @1128) -> @32 @904 @45 +@1144 := @1136 @1067 +@1152 := {t : @76} -> (h : @914 @4) -> (hs : @594 @47) -> @32 (@917 @596) @45 +@1153 := @1144 @21 +@1158 := (h : @928) -> (hs : @604) -> @32 (@929 @593) @21 +@1159 := @1153 @47 +@1165 := (hs : @32 @1067 @21) -> @32 (@939 @538) @21 +@1166 := @1159 @4 +@1169 := @32 (@893 @1067) @21 +@1173 := fun (__x0 : @17) => fun (__x1 : @26) => fun (__ih0 : @1032) => fun (__ih1 : @716) => @1166 +@1186 := fun (__v : @3) => + Coverage.Syntax.Expr.rec.{0} @16 @24 @35 @379 @530 @719 @888 @1036 @1065 @1173 @4 +@1187 := (__v : @3) -> @15 +@1200 := fun (__v : @17) => + Coverage.Syntax.Stmt.rec.{0} @16 @24 @35 @379 @530 @719 @888 @1036 @1065 @1173 @4 +@1201 := (__v : @17) -> @23 +@1214 := fun (__v : @26) => + Coverage.Syntax.Expr.rec_1.{0} @16 @24 @35 @379 @530 @719 @888 @1036 @1065 @1173 @4 +@1215 := (__v : @26) -> @34 +@1217 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wt_0 @47 +@1220 := Prod.{0, 0} @42 @75 +@1224 := Prod.mk.{0, 0} @42 @75 @9 +@1225 := @1224 @524 +@1226 := @77 @1220 +@1227 := @78 @1220 +@1229 := @1227 @1225 @1226 +@1230 := Bool.true +@1231 := LexLeanTarget.TargetSyntax.Function +@1232 := LexLeanTarget.TargetSyntax.Program.functions +@1233 := @1232 @0 +@1234 := @77 @42 +@1235 := LexLeanTarget.TargetSyntax.Ty.unit +@1236 := LexLeanTarget.TargetSyntax.Value.unit +@1239 := LexLeanTarget.TargetSyntax.Expr.value @1235 @1236 +@1244 := LexLeanTarget.TargetSyntax.Function.mk @1234 @83 @1235 @1239 +@1249 := List.getD.{0} @1231 @1233 @9 @1244 +@1253 := fun (__e_n : @42) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.root @4 @9 +@1255 := @777 @1217 @111 +@1256 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.denote +@1257 := @1256 @47 +@1258 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.__fits_0 +@1259 := @1258 @47 +@1262 := @36 (Coverage.RecRoots.syntaxTotal @47) +@1264 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.root @47 +@1265 := Bool +@1266 := Ne.{1} +@1267 := LexLeanPreservation.Obs +@1268 := @1266 @1267 +@1269 := LexLeanPreservation.Rel +@1272 := @1268 (@1269 @47 @4) +@1273 := LexLeanPreservation.Obs.stuck +@1276 := (f : @1265) -> (v : @75) -> @1272 @1273 +@1278 := LexLeanPreservation.Rust.rel_ne_stuck @1259 +@1284 := (v : @75) -> @1268 (@1269 (@1258 @45) @4) @1273 +@1285 := @1278 @1262 +@1289 := @1268 (@1269 @1259 @1262) @1273 +@1290 := @25 @1220 +@1291 := LexLeanPreservation.Rust.FunSem +@1292 := #9 +@1298 := (n : @42) -> @1291 @1292 @131 @125 @4 @117 +@1299 := @259 @1231 +@1300 := @258 @1299 +@1307 := LexLeanRuntime.index (@25 @1231) @1231 (LexLeanRuntime.instIndexableList @1231) +@1311 := @1300 (@1307 (@1232 @1292) @117) +@1312 := @267 @1231 +@1313 := @1312 @119 +@1314 := @1311 @1313 +@1315 := #10 +@1319 := @87 @1315 @1292 @131 @119 +@1320 := LexLeanTarget.TargetSyntax.Function.types +@1321 := @1320 @117 +@1322 := @1319 @1321 +@1323 := @259 @1290 +@1324 := @258 @1323 +@1325 := LexLeanTarget.TargetSemantics.bindAll +@1326 := LexLeanTarget.TargetSyntax.Function.parameters +@1331 := @1324 (@1325 (@1326 @125) @117 @1226) +@1332 := @267 @1290 +@1333 := @1332 @119 +@1334 := @1331 @1333 +@1335 := @259 @1265 +@1336 := @258 @1335 +@1337 := LexLeanPreservation.Rust.fnFallible +@1338 := #11 +@1341 := @1336 (@1337 @1338 @1292) +@1342 := @267 @1265 +@1343 := @1342 @119 +@1344 := @1341 @1343 +@1345 := LexLeanPreservation.RunConv +@1346 := #13 +@1350 := @1345 @1346 @1315 @131 @119 +@1352 := @1268 @117 @1273 +@1353 := Exists.{1} +@1354 := LexLeanPreservation.Rust.ROut +@1355 := @1353 @1354 +@1356 := And +@1357 := LexLeanPreservation.Rust.RealizesFn +@1361 := @1356 (@1357 @1292 @131 @4) +@1362 := LexLeanPreservation.Rust.RCI +@1364 := @1362 #15 +@1365 := LexLeanPreservation.Rust.fnIdent +@1366 := @1365 @1346 +@1373 := (hne : @1352) -> @1355 (fun (ro : @1354) => @1361 (@1364 @1366 @1338 @4)) +@1388 := {p : @39} -> + {c : @40} -> + {A : @41} -> + {f : @42} -> + {fn : @1231} -> + {args : @115} -> + {env : @1290} -> + {F : @1265} -> + {o : @1267} -> + (hB : @1298) -> + (hfn : @1314) -> (hwt : @1322) -> (hbind : @1334) -> (hF : @1344) -> (hA : @1350) -> @1373 +@1390 := LexLeanPreservation.Rust.compose @0 +@1391 := @1291 @0 +@1396 := (n : @42) -> @1391 @131 @125 @4 @117 +@1397 := @1307 @1233 +@1400 := @1300 (@1397 @117) @1313 +@1404 := @98 @1292 @131 @119 @1321 +@1405 := @1345 @0 +@1408 := @1405 @1315 @131 @119 +@1422 := {c : @40} -> + {A : @41} -> + {f : @42} -> + {fn : @1231} -> + {args : @115} -> + {env : @1290} -> + {F : @1265} -> + {o : @1267} -> + (hB : @1396) -> + (hfn : @1400) -> (hwt : @1404) -> (hbind : @1334) -> (hF : @1344) -> (hA : @1408) -> @1373 +@1423 := @1390 @1 +@1424 := @1391 @1 +@1428 := (n : @42) -> @1424 @125 @4 @117 +@1431 := @106 @131 @119 @1321 +@1432 := @1337 @1 +@1435 := @1336 (@1432 @1292) @1343 +@1436 := @1362 @1 +@1446 := (hbind : @1334) -> + (hF : @1435) -> + (hA : @1408) -> (hne : @1352) -> @1355 (fun (ro : @1354) => @1361 (@1436 @1366 @1338 @4)) +@1456 := {A : @41} -> + {f : @42} -> + {fn : @1231} -> + {args : @115} -> + {env : @1290} -> + {F : @1265} -> {o : @1267} -> (hB : @1428) -> (hfn : @1400) -> (hwt : @1431) -> @1446 +@1457 := @1423 @2 +@1459 := @1424 @2 @4 +@1461 := (n : @42) -> @1459 @117 +@1462 := @112 @119 +@1463 := @1462 @1321 +@1472 := {f : @42} -> + {fn : @1231} -> + {args : @115} -> + {env : @1290} -> + {F : @1265} -> {o : @1267} -> (hB : @1461) -> (hfn : @1400) -> (hwt : @1463) -> @1446 +@1473 := @1457 @9 +@1475 := (n : @42) -> @1459 @9 +@1476 := @1397 @9 +@1477 := @1300 @1476 +@1478 := @1477 @1313 +@1479 := @1432 @9 +@1480 := @1336 @1479 +@1481 := @1480 @1343 +@1482 := @1405 @9 +@1484 := @1482 @131 @119 +@1486 := @1436 (@1365 @9) +@1494 := (hF : @1481) -> + (hA : @1484) -> (hne : @1352) -> @1355 (fun (ro : @1354) => @1361 (@1486 @1338 @4)) +@1503 := {fn : @1231} -> + {args : @115} -> + {env : @1290} -> + {F : @1265} -> + {o : @1267} -> (hB : @1475) -> (hfn : @1478) -> (hwt : @1463) -> (hbind : @1334) -> @1494 +@1504 := @1473 @1249 +@1506 := @1477 (@1312 @1249) +@1507 := @1320 @1249 +@1508 := @1462 @1507 +@1510 := @1325 (@1326 @1249) +@1522 := {args : @115} -> + {env : @1290} -> + {F : @1265} -> + {o : @1267} -> + (hB : @1475) -> + (hfn : @1506) -> (hwt : @1508) -> (hbind : @1324 (@1510 @117 @1226) @1333) -> @1494 +@1523 := @1504 @751 +@1524 := @408 @79 +@1526 := @112 @1524 @1507 +@1527 := @394 @79 +@1531 := @1324 (@1510 @1527 @1226) @1333 +@1534 := @80 (@5 @1292) @79 +@1555 := {env : @1290} -> + {F : @1265} -> + {o : @1267} -> + (hB : @1475) -> + (hfn : @1506) -> + (hwt : @1526) -> + (hbind : @1531) -> + (hF : @1481) -> + (hA : @1482 @1534 @119) -> + (hne : @1352) -> @1355 (fun (ro : @1354) => @1361 (@1486 (@80 (@5 #12) @79) @4)) +@1556 := @1523 @1229 +@1557 := @422 @1507 +@1565 := @1324 (@1510 @1524 @1226) (@1332 (@1227 (@1224 @407) @1226)) +@1566 := @448 @79 +@1585 := {F : @1265} -> + {o : @1267} -> + (hB : @1475) -> + (hfn : @1506) -> + (hwt : @1557) -> + (hbind : @1565) -> + (hF : @1481) -> + (hA : @1482 @1566 @119) -> + (hne : @1352) -> @1355 (fun (ro : @1354) => @1361 (@1486 (@80 (@5 @1338) @79) @4)) +@1586 := @1556 @1230 +@1587 := @432 @1507 +@1595 := @1324 (@1510 @421 @1226) (@1332 (@1227 (@1224 @390) @1226)) +@1597 := @1480 (@1342 @1230) +@1599 := @1482 @1527 @119 +@1600 := @1357 @1230 +@1619 := {o : @1267} -> + (hB : @1475) -> + (hfn : @1506) -> + (hwt : @1587) -> + (hbind : @1595) -> + (hF : @1597) -> + (hA : @1599) -> + (hne : @1352) -> @1355 (fun (ro : @1354) => @1356 (@1600 @131 @4) (@1486 (@80 (@5 @1315) @79) @4)) +@1620 := @1586 @1257 +@1621 := @438 @1507 +@1629 := @1324 (@1510 @431 @1226) (@1332 (@1227 (@1224 @404) @1226)) +@1630 := @1482 @1524 +@1631 := @1256 @117 +@1632 := @1630 @1631 +@1633 := @1256 @125 +@1651 := (hB : @1475) -> + (hfn : @1506) -> + (hwt : @1621) -> + (hbind : @1629) -> + (hF : @1597) -> + (hA : @1632) -> + (hne : @1268 @1633 @1273) -> + @1355 (fun (ro : @1354) => @1356 (@1600 (@1256 @1292) @4) (@1486 @1534 @4)) +@1652 := @1620 @1253 +@1653 := @442 @1507 +@1661 := @1324 (@1510 @437 @1226) (@1332 (@1227 (@1224 @380) @1226)) +@1662 := @1482 @421 +@1663 := @1256 @119 +@1681 := (hfn : @1506) -> + (hwt : @1653) -> + (hbind : @1661) -> + (hF : @1597) -> + (hA : @1662 @1663) -> + (hne : @1268 @1631 @1273) -> + @1355 (fun (ro : @1354) => @1356 (@1600 (@1256 @131) @4) (@1486 @1566 @4)) +@1684 := @1652 (@367 @1299 @1476) +@1685 := @782 @1507 +@1693 := @1324 (@1510 @383 @1226) (@1332 (@1227 (@1224 @381) @1226)) +@1694 := @1482 @431 +@1695 := @1256 @121 +@1711 := (hwt : @1685) -> + (hbind : @1693) -> + (hF : @1597) -> + (hA : @1694 @1695) -> + (hne : @1268 @1663 @1273) -> @1355 (fun (ro : @1354) => @1356 (@1600 @1633 @4) (@1486 @1527 @4)) +@1712 := @1684 @1255 +@1714 := @1510 @751 @1226 +@1717 := @1324 @1714 (@1332 @1229) +@1718 := @1482 @437 +@1719 := @1256 @43 +@1734 := (hbind : @1717) -> + (hF : @1597) -> + (hA : @1718 @1719) -> + (hne : @1268 @1695 @1273) -> @1355 (fun (ro : @1354) => @1356 (@1600 @1631 @4) (@1486 @1524 @4)) +@1737 := @1712 (@367 @1323 @1714) +@1738 := @1482 @383 +@1739 := @1256 @45 +@1753 := (hF : @1597) -> + (hA : @1738 @1739) -> + (hne : @1268 @1719 @1273) -> @1355 (fun (ro : @1354) => @1356 (@1600 @1663 @4) (@1486 @421 @4)) +@1756 := @1737 (@367 @1335 @1479) +@1770 := (hA : @1482 @751 @1257) -> + (hne : @1268 @1739 @1273) -> @1355 (fun (ro : @1354) => @1356 (@1600 @1695 @4) (@1486 @431 @4)) +@1771 := @1756 @1264 +@1782 := (hne : @1268 @1257 @1273) -> + @1355 (fun (ro : @1354) => @1356 (@1600 @1719 @4) (@1486 @437 @4)) +@1783 := @1771 @1285 +@1789 := @1356 (@1600 @1739 @4) (@1486 @383 @4) +@1791 := @1355 (fun (ro : @1354) => @1789) +@1793 := @1355 (fun (__e_ro : @1354) => @1789) +@1797 := LexLeanPreservation.Rust.RepresentableL (@80 @6 @79) +@1798 := (__e_hrep : @1797) -> @1793 +@1799 := fun (__e_hrep : @1797) => @1783 +@1800 := (e : @3) -> @1798 +@1801 := fun (e : @3) => @1799 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustCore.lean deleted file mode 100644 index 1731995ca..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Nat) (b : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustCore.lex.tex new file mode 100644 index 000000000..fbb315cbc --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustCore.lex.tex @@ -0,0 +1,467 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore.root : @923 := @924 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@64 := Prod.{0, 0} @3 +@65 := @64 @54 +@66 := 1 +@69 := Prod.mk.{0, 0} @3 @54 +@70 := @69 @66 +@71 := @70 @50 +@72 := 0 +@73 := @69 @72 +@74 := @73 @6 +@75 := @55 @65 +@76 := @56 @65 +@78 := @76 @74 @75 +@80 := @76 @71 @78 +@81 := Bool.true +@82 := LexLeanTarget.TargetSyntax.Function +@83 := LexLeanTarget.TargetSyntax.Program.functions +@84 := @83 @0 +@85 := LexLeanTarget.TargetSyntax.Ty +@86 := @55 @3 +@87 := @55 @85 +@88 := LexLeanTarget.TargetSyntax.Ty.unit +@89 := LexLeanTarget.TargetSyntax.Value.unit +@92 := LexLeanTarget.TargetSyntax.Expr.value @88 @89 +@97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 +@102 := List.getD.{0} @82 @84 @72 @97 +@106 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore.root @17 @72 +@107 := LexLeanPreservation.Rust.WTL +@115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 +@117 := LexLeanPreservation.Rust.wtl_nil @0 +@118 := @107 @0 +@124 := {c : @9} -> {A : @10} -> @118 @15 @17 @57 @87 +@125 := @117 @1 +@126 := @118 @1 +@130 := {A : @10} -> @126 @17 @57 @87 +@131 := @125 @2 +@132 := @126 @2 +@133 := @132 @57 +@134 := @133 @87 +@135 := List.{0} +@136 := @135 @54 +@137 := @135 @85 +@138 := #6 +@139 := @11 @138 +@140 := #5 +@141 := @139 @140 +@142 := #4 +@145 := @141 @142 @12 @4 +@146 := #7 +@151 := @107 @146 @138 @140 @4 @15 +@152 := #8 +@155 := @107 @152 @146 @138 +@157 := @58 @140 @12 +@158 := @155 @157 +@159 := @56 @85 +@161 := @159 @142 @4 +@171 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @145) -> (hs : @151) -> @158 @161 +@173 := LexLeanPreservation.Rust.wtl_cons @0 +@193 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> + (h : @27 @140 @142 @12 @4) -> (hs : @118 @138 @140 @4 @15) -> @118 @146 @138 @157 @161 +@194 := @173 @1 +@210 := {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> (h : @36 @142 @12 @4) -> (hs : @126 @140 @4 @15) -> @126 @138 @157 @161 +@211 := @194 @2 +@213 := @43 @12 @4 +@215 := @132 @4 @15 +@223 := {v : @54} -> + {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @213) -> (hs : @215) -> @132 @157 @161 +@224 := @211 @50 +@225 := @5 @142 +@226 := @43 @225 +@227 := @226 @4 +@228 := @5 @138 +@229 := @58 @228 +@231 := @132 (@229 @12) +@237 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @227) -> (hs : @215) -> @231 @161 +@238 := @224 @7 +@239 := @5 @12 +@241 := @43 @239 @7 +@242 := @5 @140 +@243 := @58 @242 +@245 := @132 (@243 @12) +@246 := @159 @7 +@247 := @246 @4 +@252 := {vs : @136} -> {ts : @137} -> (h : @241) -> (hs : @215) -> @245 @247 +@253 := @238 @57 +@254 := @133 @15 +@255 := @58 @225 +@256 := @255 @57 +@261 := {ts : @137} -> (h : @49) -> (hs : @254) -> @132 @256 @247 +@262 := @253 @87 +@263 := @58 @239 +@264 := @263 @57 +@265 := @132 @264 +@266 := @246 @87 +@269 := (h : @53) -> (hs : @134) -> @265 @266 +@270 := @262 @51 +@271 := @61 @57 +@273 := @132 @271 @266 +@274 := (hs : @134) -> @273 +@275 := @270 @131 +@277 := @132 @60 @266 +@278 := @211 @6 +@280 := @43 @242 @4 +@281 := @5 @146 +@282 := @58 @281 +@290 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @280) -> (hs : @215) -> @132 (@282 @12) @161 +@291 := @278 @7 +@297 := {vs : @136} -> {ts : @137} -> (h : @226 @7) -> (hs : @215) -> @231 @247 +@298 := @291 @60 +@299 := @265 @15 +@300 := @243 @256 +@301 := @132 @300 +@305 := {ts : @137} -> (h : @241) -> (hs : @299) -> @301 @247 +@306 := @298 @266 +@307 := @255 @264 +@308 := @132 @307 +@309 := @246 @266 +@312 := (h : @49) -> (hs : @273) -> @308 @309 +@313 := @306 @47 +@314 := @263 @271 +@315 := @132 @314 +@317 := (hs : @277) -> @315 @309 +@318 := @313 @275 +@319 := @132 @62 +@320 := @319 @309 +@321 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.__fits_0 +@326 := @324 @4 @15 +@329 := Coverage.RecRoots.wellFounded @4 @15 +@330 := @64 @3 +@332 := LexLeanPreservation.encPair @3 +@335 := @332 @3 @5 @5 +@339 := @332 @330 @5 @335 @329 +@342 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.root @4 @15 +@343 := Bool +@344 := Ne.{1} +@345 := LexLeanPreservation.Obs +@346 := @344 @345 +@347 := LexLeanPreservation.Rel +@350 := @346 (@347 @15 @17) +@351 := LexLeanPreservation.Obs.stuck +@354 := (f : @343) -> (v : @54) -> @350 @351 +@356 := LexLeanPreservation.Rust.rel_ne_stuck @326 +@363 := (v : @54) -> @346 (@347 (@324 @12 @4) @17) @351 +@364 := @356 @339 +@368 := @346 (@347 @326 @339) @351 +@369 := @135 @65 +@370 := LexLeanPreservation.Rust.FunSem +@371 := #9 +@377 := (n : @3) -> @370 @371 @152 @146 @17 @138 +@378 := Eq.{1} +@379 := Option.{0} +@380 := @379 @82 +@381 := @378 @380 +@388 := LexLeanRuntime.index (@135 @82) @82 (LexLeanRuntime.instIndexableList @82) +@392 := @381 (@388 (@83 @371) @138) +@393 := Option.some.{0} +@394 := @393 @82 +@395 := @394 @140 +@396 := @392 @395 +@397 := #10 +@401 := @107 @397 @371 @152 @140 +@402 := LexLeanTarget.TargetSyntax.Function.types +@403 := @402 @138 +@404 := @401 @403 +@405 := @379 @369 +@406 := @378 @405 +@407 := LexLeanTarget.TargetSemantics.bindAll +@408 := LexLeanTarget.TargetSyntax.Function.parameters +@413 := @406 (@407 (@408 @146) @138 @75) +@414 := @393 @369 +@415 := @414 @140 +@416 := @413 @415 +@417 := @379 @343 +@418 := @378 @417 +@419 := LexLeanPreservation.Rust.fnFallible +@420 := #11 +@423 := @418 (@419 @420 @371) +@424 := @393 @343 +@425 := @424 @140 +@426 := @423 @425 +@427 := LexLeanPreservation.RunConv +@428 := #13 +@432 := @427 @428 @397 @152 @140 +@434 := @346 @138 @351 +@435 := Exists.{1} +@436 := LexLeanPreservation.Rust.ROut +@437 := @435 @436 +@438 := And +@439 := LexLeanPreservation.Rust.RealizesFn +@443 := @438 (@439 @371 @152 @17) +@444 := LexLeanPreservation.Rust.RCI +@446 := @444 #15 +@447 := LexLeanPreservation.Rust.fnIdent +@448 := @447 @428 +@455 := (hne : @434) -> @437 (fun (ro : @436) => @443 (@446 @448 @420 @17)) +@470 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @369} -> + {F : @343} -> + {o : @345} -> + (hB : @377) -> + (hfn : @396) -> (hwt : @404) -> (hbind : @416) -> (hF : @426) -> (hA : @432) -> @455 +@472 := LexLeanPreservation.Rust.compose @0 +@473 := @370 @0 +@478 := (n : @3) -> @473 @152 @146 @17 @138 +@479 := @388 @84 +@482 := @381 (@479 @138) @395 +@486 := @118 @371 @152 @140 @403 +@487 := @427 @0 +@490 := @487 @397 @152 @140 +@504 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @369} -> + {F : @343} -> + {o : @345} -> + (hB : @478) -> + (hfn : @482) -> (hwt : @486) -> (hbind : @416) -> (hF : @426) -> (hA : @490) -> @455 +@505 := @472 @1 +@506 := @473 @1 +@510 := (n : @3) -> @506 @146 @17 @138 +@513 := @126 @152 @140 @403 +@514 := @419 @1 +@517 := @418 (@514 @371) @425 +@518 := @444 @1 +@528 := (hbind : @416) -> + (hF : @517) -> (hA : @490) -> (hne : @434) -> @437 (fun (ro : @436) => @443 (@518 @448 @420 @17)) +@538 := {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @369} -> {F : @343} -> {o : @345} -> (hB : @510) -> (hfn : @482) -> (hwt : @513) -> @528 +@539 := @505 @2 +@541 := @506 @2 @17 +@543 := (n : @3) -> @541 @138 +@544 := @132 @140 +@545 := @544 @403 +@554 := {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @369} -> {F : @343} -> {o : @345} -> (hB : @543) -> (hfn : @482) -> (hwt : @545) -> @528 +@555 := @539 @72 +@557 := (n : @3) -> @541 @72 +@558 := @479 @72 +@559 := @381 @558 +@560 := @559 @395 +@561 := @514 @72 +@562 := @418 @561 +@563 := @562 @425 +@564 := @487 @72 +@566 := @564 @152 @140 +@568 := @518 (@447 @72) +@576 := (hF : @563) -> (hA : @566) -> (hne : @434) -> @437 (fun (ro : @436) => @443 (@568 @420 @17)) +@585 := {fn : @82} -> + {args : @136} -> + {env : @369} -> + {F : @343} -> {o : @345} -> (hB : @557) -> (hfn : @560) -> (hwt : @545) -> (hbind : @416) -> @576 +@586 := @555 @102 +@588 := @559 (@394 @102) +@589 := @402 @102 +@590 := @544 @589 +@592 := @407 (@408 @102) +@604 := {args : @136} -> + {env : @369} -> + {F : @343} -> + {o : @345} -> + (hB : @557) -> (hfn : @588) -> (hwt : @590) -> (hbind : @406 (@592 @138 @75) @415) -> @576 +@605 := @586 @62 +@607 := @282 (@229 @57) +@609 := @132 @607 @589 +@611 := @58 (@5 @152) +@613 := @611 (@282 @57) +@617 := @406 (@592 @613 @75) @415 +@619 := @58 (@5 @397) +@621 := @58 (@5 @371) +@623 := @619 (@621 @57) +@625 := @564 @623 @140 +@627 := @58 (@5 @428) +@630 := @58 (@5 #12) +@647 := {env : @369} -> + {F : @343} -> + {o : @345} -> + (hB : @557) -> + (hfn : @588) -> + (hwt : @609) -> + (hbind : @617) -> + (hF : @563) -> + (hA : @625) -> (hne : @434) -> @437 (fun (ro : @436) => @443 (@568 (@627 (@630 @57)) @17)) +@648 := @605 @80 +@650 := @229 (@243 @57) +@652 := @132 @650 @589 +@663 := @406 (@592 @607 @75) (@414 (@76 (@70 @228) (@76 (@73 @281) @75))) +@665 := @621 (@611 @57) +@667 := @564 @665 @140 +@669 := @58 (@5 @420) +@685 := {F : @343} -> + {o : @345} -> + (hB : @557) -> + (hfn : @588) -> + (hwt : @652) -> + (hbind : @663) -> + (hF : @563) -> + (hA : @667) -> (hne : @434) -> @437 (fun (ro : @436) => @443 (@568 (@630 (@669 @57)) @17)) +@686 := @648 @81 +@687 := @301 @589 +@698 := @406 (@592 @650 @75) (@414 (@76 (@70 @242) (@76 (@73 @228) @75))) +@700 := @562 (@424 @81) +@702 := @564 @613 @140 +@703 := @439 @81 +@721 := {o : @345} -> + (hB : @557) -> + (hfn : @588) -> + (hwt : @687) -> + (hbind : @698) -> + (hF : @700) -> + (hA : @702) -> + (hne : @434) -> @437 (fun (ro : @436) => @438 (@703 @152 @17) (@568 (@669 (@619 @57)) @17)) +@722 := @686 @323 +@723 := @308 @589 +@734 := @406 (@592 @300 @75) (@414 (@76 (@70 @225) (@76 (@73 @242) @75))) +@735 := @564 @607 +@737 := @321 @146 @138 +@738 := @735 @737 +@740 := @321 @152 @146 +@759 := (hB : @557) -> + (hfn : @588) -> + (hwt : @723) -> + (hbind : @734) -> + (hF : @700) -> + (hA : @738) -> + (hne : @346 @740 @351) -> + @437 (fun (ro : @436) => @438 (@703 (@321 @397 @371) @17) (@568 @623 @17)) +@760 := @722 @106 +@761 := @315 @589 +@772 := @406 (@592 @307 @75) (@414 (@76 (@70 @239) (@76 (@73 @225) @75))) +@773 := @564 @650 +@775 := @321 @138 @140 +@794 := (hfn : @588) -> + (hwt : @761) -> + (hbind : @772) -> + (hF : @700) -> + (hA : @773 @775) -> + (hne : @346 @737 @351) -> + @437 (fun (ro : @436) => @438 (@703 (@321 @371 @152) @17) (@568 @665 @17)) +@795 := Eq.refl.{1} +@798 := @760 (@795 @380 @558) +@799 := @319 @589 +@810 := @406 (@592 @314 @75) (@414 (@76 (@70 @6) (@76 (@73 @239) @75))) +@811 := @564 @300 +@813 := @321 @140 @142 +@829 := (hwt : @799) -> + (hbind : @810) -> + (hF : @700) -> + (hA : @811 @813) -> + (hne : @346 @775 @351) -> @437 (fun (ro : @436) => @438 (@703 @740 @17) (@568 @613 @17)) +@830 := @798 @318 +@832 := @592 @62 @75 +@835 := @406 @832 (@414 @80) +@836 := @564 @307 +@838 := @321 @142 @12 +@853 := (hbind : @835) -> + (hF : @700) -> + (hA : @836 @838) -> + (hne : @346 @813 @351) -> @437 (fun (ro : @436) => @438 (@703 @737 @17) (@568 @607 @17)) +@856 := @830 (@795 @405 @832) +@857 := @564 @314 +@859 := @321 @12 @4 +@873 := (hF : @700) -> + (hA : @857 @859) -> + (hne : @346 @838 @351) -> @437 (fun (ro : @436) => @438 (@703 @775 @17) (@568 @650 @17)) +@876 := @856 (@795 @417 @561) +@890 := (hA : @564 @62 @323) -> + (hne : @346 @859 @351) -> @437 (fun (ro : @436) => @438 (@703 @813 @17) (@568 @300 @17)) +@891 := @876 @342 +@902 := (hne : @346 @323 @351) -> @437 (fun (ro : @436) => @438 (@703 @838 @17) (@568 @307 @17)) +@903 := @891 @364 +@909 := @438 (@703 @859 @17) (@568 @314 @17) +@911 := @437 (fun (ro : @436) => @909) +@913 := @437 (fun (__e_ro : @436) => @909) +@918 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@919 := (__e_hrep : @918) -> @913 +@920 := fun (__e_hrep : @918) => @903 +@921 := (b : @3) -> @919 +@922 := fun (b : @3) => @920 +@923 := (a : @3) -> @921 +@924 := fun (a : @3) => @922 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustStd.lean deleted file mode 100644 index 517a4bcd3..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (a : Nat) (b : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat a), (_root_.LexLeanTarget.TargetSyntax.Value.nat b)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat a) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat b) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustStd.lex.tex new file mode 100644 index 000000000..11eb98bdc --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustStd.lex.tex @@ -0,0 +1,467 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd.root : @923 := @924 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@64 := Prod.{0, 0} @3 +@65 := @64 @54 +@66 := 1 +@69 := Prod.mk.{0, 0} @3 @54 +@70 := @69 @66 +@71 := @70 @50 +@72 := 0 +@73 := @69 @72 +@74 := @73 @6 +@75 := @55 @65 +@76 := @56 @65 +@78 := @76 @74 @75 +@80 := @76 @71 @78 +@81 := Bool.true +@82 := LexLeanTarget.TargetSyntax.Function +@83 := LexLeanTarget.TargetSyntax.Program.functions +@84 := @83 @0 +@85 := LexLeanTarget.TargetSyntax.Ty +@86 := @55 @3 +@87 := @55 @85 +@88 := LexLeanTarget.TargetSyntax.Ty.unit +@89 := LexLeanTarget.TargetSyntax.Value.unit +@92 := LexLeanTarget.TargetSyntax.Expr.value @88 @89 +@97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 +@102 := List.getD.{0} @82 @84 @72 @97 +@106 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd.root @17 @72 +@107 := LexLeanPreservation.Rust.WTL +@115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 +@117 := LexLeanPreservation.Rust.wtl_nil @0 +@118 := @107 @0 +@124 := {c : @9} -> {A : @10} -> @118 @15 @17 @57 @87 +@125 := @117 @1 +@126 := @118 @1 +@130 := {A : @10} -> @126 @17 @57 @87 +@131 := @125 @2 +@132 := @126 @2 +@133 := @132 @57 +@134 := @133 @87 +@135 := List.{0} +@136 := @135 @54 +@137 := @135 @85 +@138 := #6 +@139 := @11 @138 +@140 := #5 +@141 := @139 @140 +@142 := #4 +@145 := @141 @142 @12 @4 +@146 := #7 +@151 := @107 @146 @138 @140 @4 @15 +@152 := #8 +@155 := @107 @152 @146 @138 +@157 := @58 @140 @12 +@158 := @155 @157 +@159 := @56 @85 +@161 := @159 @142 @4 +@171 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @145) -> (hs : @151) -> @158 @161 +@173 := LexLeanPreservation.Rust.wtl_cons @0 +@193 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> + (h : @27 @140 @142 @12 @4) -> (hs : @118 @138 @140 @4 @15) -> @118 @146 @138 @157 @161 +@194 := @173 @1 +@210 := {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> (h : @36 @142 @12 @4) -> (hs : @126 @140 @4 @15) -> @126 @138 @157 @161 +@211 := @194 @2 +@213 := @43 @12 @4 +@215 := @132 @4 @15 +@223 := {v : @54} -> + {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @213) -> (hs : @215) -> @132 @157 @161 +@224 := @211 @50 +@225 := @5 @142 +@226 := @43 @225 +@227 := @226 @4 +@228 := @5 @138 +@229 := @58 @228 +@231 := @132 (@229 @12) +@237 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @227) -> (hs : @215) -> @231 @161 +@238 := @224 @7 +@239 := @5 @12 +@241 := @43 @239 @7 +@242 := @5 @140 +@243 := @58 @242 +@245 := @132 (@243 @12) +@246 := @159 @7 +@247 := @246 @4 +@252 := {vs : @136} -> {ts : @137} -> (h : @241) -> (hs : @215) -> @245 @247 +@253 := @238 @57 +@254 := @133 @15 +@255 := @58 @225 +@256 := @255 @57 +@261 := {ts : @137} -> (h : @49) -> (hs : @254) -> @132 @256 @247 +@262 := @253 @87 +@263 := @58 @239 +@264 := @263 @57 +@265 := @132 @264 +@266 := @246 @87 +@269 := (h : @53) -> (hs : @134) -> @265 @266 +@270 := @262 @51 +@271 := @61 @57 +@273 := @132 @271 @266 +@274 := (hs : @134) -> @273 +@275 := @270 @131 +@277 := @132 @60 @266 +@278 := @211 @6 +@280 := @43 @242 @4 +@281 := @5 @146 +@282 := @58 @281 +@290 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @280) -> (hs : @215) -> @132 (@282 @12) @161 +@291 := @278 @7 +@297 := {vs : @136} -> {ts : @137} -> (h : @226 @7) -> (hs : @215) -> @231 @247 +@298 := @291 @60 +@299 := @265 @15 +@300 := @243 @256 +@301 := @132 @300 +@305 := {ts : @137} -> (h : @241) -> (hs : @299) -> @301 @247 +@306 := @298 @266 +@307 := @255 @264 +@308 := @132 @307 +@309 := @246 @266 +@312 := (h : @49) -> (hs : @273) -> @308 @309 +@313 := @306 @47 +@314 := @263 @271 +@315 := @132 @314 +@317 := (hs : @277) -> @315 @309 +@318 := @313 @275 +@319 := @132 @62 +@320 := @319 @309 +@321 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.__fits_0 +@326 := @324 @4 @15 +@329 := Coverage.RecRoots.wellFounded @4 @15 +@330 := @64 @3 +@332 := LexLeanPreservation.encPair @3 +@335 := @332 @3 @5 @5 +@339 := @332 @330 @5 @335 @329 +@342 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.root @4 @15 +@343 := Bool +@344 := Ne.{1} +@345 := LexLeanPreservation.Obs +@346 := @344 @345 +@347 := LexLeanPreservation.Rel +@350 := @346 (@347 @15 @17) +@351 := LexLeanPreservation.Obs.stuck +@354 := (f : @343) -> (v : @54) -> @350 @351 +@356 := LexLeanPreservation.Rust.rel_ne_stuck @326 +@363 := (v : @54) -> @346 (@347 (@324 @12 @4) @17) @351 +@364 := @356 @339 +@368 := @346 (@347 @326 @339) @351 +@369 := @135 @65 +@370 := LexLeanPreservation.Rust.FunSem +@371 := #9 +@377 := (n : @3) -> @370 @371 @152 @146 @17 @138 +@378 := Eq.{1} +@379 := Option.{0} +@380 := @379 @82 +@381 := @378 @380 +@388 := LexLeanRuntime.index (@135 @82) @82 (LexLeanRuntime.instIndexableList @82) +@392 := @381 (@388 (@83 @371) @138) +@393 := Option.some.{0} +@394 := @393 @82 +@395 := @394 @140 +@396 := @392 @395 +@397 := #10 +@401 := @107 @397 @371 @152 @140 +@402 := LexLeanTarget.TargetSyntax.Function.types +@403 := @402 @138 +@404 := @401 @403 +@405 := @379 @369 +@406 := @378 @405 +@407 := LexLeanTarget.TargetSemantics.bindAll +@408 := LexLeanTarget.TargetSyntax.Function.parameters +@413 := @406 (@407 (@408 @146) @138 @75) +@414 := @393 @369 +@415 := @414 @140 +@416 := @413 @415 +@417 := @379 @343 +@418 := @378 @417 +@419 := LexLeanPreservation.Rust.fnFallible +@420 := #11 +@423 := @418 (@419 @420 @371) +@424 := @393 @343 +@425 := @424 @140 +@426 := @423 @425 +@427 := LexLeanPreservation.RunConv +@428 := #13 +@432 := @427 @428 @397 @152 @140 +@434 := @346 @138 @351 +@435 := Exists.{1} +@436 := LexLeanPreservation.Rust.ROut +@437 := @435 @436 +@438 := And +@439 := LexLeanPreservation.Rust.RealizesFn +@443 := @438 (@439 @371 @152 @17) +@444 := LexLeanPreservation.Rust.RCI +@446 := @444 #15 +@447 := LexLeanPreservation.Rust.fnIdent +@448 := @447 @428 +@455 := (hne : @434) -> @437 (fun (ro : @436) => @443 (@446 @448 @420 @17)) +@470 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @369} -> + {F : @343} -> + {o : @345} -> + (hB : @377) -> + (hfn : @396) -> (hwt : @404) -> (hbind : @416) -> (hF : @426) -> (hA : @432) -> @455 +@472 := LexLeanPreservation.Rust.compose @0 +@473 := @370 @0 +@478 := (n : @3) -> @473 @152 @146 @17 @138 +@479 := @388 @84 +@482 := @381 (@479 @138) @395 +@486 := @118 @371 @152 @140 @403 +@487 := @427 @0 +@490 := @487 @397 @152 @140 +@504 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @369} -> + {F : @343} -> + {o : @345} -> + (hB : @478) -> + (hfn : @482) -> (hwt : @486) -> (hbind : @416) -> (hF : @426) -> (hA : @490) -> @455 +@505 := @472 @1 +@506 := @473 @1 +@510 := (n : @3) -> @506 @146 @17 @138 +@513 := @126 @152 @140 @403 +@514 := @419 @1 +@517 := @418 (@514 @371) @425 +@518 := @444 @1 +@528 := (hbind : @416) -> + (hF : @517) -> (hA : @490) -> (hne : @434) -> @437 (fun (ro : @436) => @443 (@518 @448 @420 @17)) +@538 := {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @369} -> {F : @343} -> {o : @345} -> (hB : @510) -> (hfn : @482) -> (hwt : @513) -> @528 +@539 := @505 @2 +@541 := @506 @2 @17 +@543 := (n : @3) -> @541 @138 +@544 := @132 @140 +@545 := @544 @403 +@554 := {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @369} -> {F : @343} -> {o : @345} -> (hB : @543) -> (hfn : @482) -> (hwt : @545) -> @528 +@555 := @539 @72 +@557 := (n : @3) -> @541 @72 +@558 := @479 @72 +@559 := @381 @558 +@560 := @559 @395 +@561 := @514 @72 +@562 := @418 @561 +@563 := @562 @425 +@564 := @487 @72 +@566 := @564 @152 @140 +@568 := @518 (@447 @72) +@576 := (hF : @563) -> (hA : @566) -> (hne : @434) -> @437 (fun (ro : @436) => @443 (@568 @420 @17)) +@585 := {fn : @82} -> + {args : @136} -> + {env : @369} -> + {F : @343} -> {o : @345} -> (hB : @557) -> (hfn : @560) -> (hwt : @545) -> (hbind : @416) -> @576 +@586 := @555 @102 +@588 := @559 (@394 @102) +@589 := @402 @102 +@590 := @544 @589 +@592 := @407 (@408 @102) +@604 := {args : @136} -> + {env : @369} -> + {F : @343} -> + {o : @345} -> + (hB : @557) -> (hfn : @588) -> (hwt : @590) -> (hbind : @406 (@592 @138 @75) @415) -> @576 +@605 := @586 @62 +@607 := @282 (@229 @57) +@609 := @132 @607 @589 +@611 := @58 (@5 @152) +@613 := @611 (@282 @57) +@617 := @406 (@592 @613 @75) @415 +@619 := @58 (@5 @397) +@621 := @58 (@5 @371) +@623 := @619 (@621 @57) +@625 := @564 @623 @140 +@627 := @58 (@5 @428) +@630 := @58 (@5 #12) +@647 := {env : @369} -> + {F : @343} -> + {o : @345} -> + (hB : @557) -> + (hfn : @588) -> + (hwt : @609) -> + (hbind : @617) -> + (hF : @563) -> + (hA : @625) -> (hne : @434) -> @437 (fun (ro : @436) => @443 (@568 (@627 (@630 @57)) @17)) +@648 := @605 @80 +@650 := @229 (@243 @57) +@652 := @132 @650 @589 +@663 := @406 (@592 @607 @75) (@414 (@76 (@70 @228) (@76 (@73 @281) @75))) +@665 := @621 (@611 @57) +@667 := @564 @665 @140 +@669 := @58 (@5 @420) +@685 := {F : @343} -> + {o : @345} -> + (hB : @557) -> + (hfn : @588) -> + (hwt : @652) -> + (hbind : @663) -> + (hF : @563) -> + (hA : @667) -> (hne : @434) -> @437 (fun (ro : @436) => @443 (@568 (@630 (@669 @57)) @17)) +@686 := @648 @81 +@687 := @301 @589 +@698 := @406 (@592 @650 @75) (@414 (@76 (@70 @242) (@76 (@73 @228) @75))) +@700 := @562 (@424 @81) +@702 := @564 @613 @140 +@703 := @439 @81 +@721 := {o : @345} -> + (hB : @557) -> + (hfn : @588) -> + (hwt : @687) -> + (hbind : @698) -> + (hF : @700) -> + (hA : @702) -> + (hne : @434) -> @437 (fun (ro : @436) => @438 (@703 @152 @17) (@568 (@669 (@619 @57)) @17)) +@722 := @686 @323 +@723 := @308 @589 +@734 := @406 (@592 @300 @75) (@414 (@76 (@70 @225) (@76 (@73 @242) @75))) +@735 := @564 @607 +@737 := @321 @146 @138 +@738 := @735 @737 +@740 := @321 @152 @146 +@759 := (hB : @557) -> + (hfn : @588) -> + (hwt : @723) -> + (hbind : @734) -> + (hF : @700) -> + (hA : @738) -> + (hne : @346 @740 @351) -> + @437 (fun (ro : @436) => @438 (@703 (@321 @397 @371) @17) (@568 @623 @17)) +@760 := @722 @106 +@761 := @315 @589 +@772 := @406 (@592 @307 @75) (@414 (@76 (@70 @239) (@76 (@73 @225) @75))) +@773 := @564 @650 +@775 := @321 @138 @140 +@794 := (hfn : @588) -> + (hwt : @761) -> + (hbind : @772) -> + (hF : @700) -> + (hA : @773 @775) -> + (hne : @346 @737 @351) -> + @437 (fun (ro : @436) => @438 (@703 (@321 @371 @152) @17) (@568 @665 @17)) +@795 := Eq.refl.{1} +@798 := @760 (@795 @380 @558) +@799 := @319 @589 +@810 := @406 (@592 @314 @75) (@414 (@76 (@70 @6) (@76 (@73 @239) @75))) +@811 := @564 @300 +@813 := @321 @140 @142 +@829 := (hwt : @799) -> + (hbind : @810) -> + (hF : @700) -> + (hA : @811 @813) -> + (hne : @346 @775 @351) -> @437 (fun (ro : @436) => @438 (@703 @740 @17) (@568 @613 @17)) +@830 := @798 @318 +@832 := @592 @62 @75 +@835 := @406 @832 (@414 @80) +@836 := @564 @307 +@838 := @321 @142 @12 +@853 := (hbind : @835) -> + (hF : @700) -> + (hA : @836 @838) -> + (hne : @346 @813 @351) -> @437 (fun (ro : @436) => @438 (@703 @737 @17) (@568 @607 @17)) +@856 := @830 (@795 @405 @832) +@857 := @564 @314 +@859 := @321 @12 @4 +@873 := (hF : @700) -> + (hA : @857 @859) -> + (hne : @346 @838 @351) -> @437 (fun (ro : @436) => @438 (@703 @775 @17) (@568 @650 @17)) +@876 := @856 (@795 @417 @561) +@890 := (hA : @564 @62 @323) -> + (hne : @346 @859 @351) -> @437 (fun (ro : @436) => @438 (@703 @813 @17) (@568 @300 @17)) +@891 := @876 @342 +@902 := (hne : @346 @323 @351) -> @437 (fun (ro : @436) => @438 (@703 @838 @17) (@568 @307 @17)) +@903 := @891 @364 +@909 := @438 (@703 @859 @17) (@568 @314 @17) +@911 := @437 (fun (ro : @436) => @909) +@913 := @437 (fun (__e_ro : @436) => @909) +@918 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@919 := (__e_hrep : @918) -> @913 +@920 := fun (__e_hrep : @918) => @903 +@921 := (b : @3) -> @919 +@922 := fun (b : @3) => @920 +@923 := (a : @3) -> @921 +@924 := fun (a : @3) => @922 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R33/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R33/Compose/RustStd.lean deleted file mode 100644 index ca9a4f0be..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R33/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Coverage.Syntax.Term)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.program _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.krate _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.flags (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.__enc_0 __v) (.adt 0) - | Coverage.Syntax.Term.literal __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - | Coverage.Syntax.Term.plus __x0 __x1 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 __x1) _root_.LexLeanPreservation.Rust.wtl_nil)) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (t : (Coverage.Syntax.Term)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.__enc_0 t)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.denote t) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.__enc_0 t)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 t) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.root t) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R33/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R33/Compose/RustStd.lex.tex new file mode 100644 index 000000000..5b82e1277 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R33/Compose/RustStd.lex.tex @@ -0,0 +1,573 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.__wt_0 : @520 := @519 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.root : @1138 := @1139 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.flags +@3 := Coverage.Syntax.Term +@4 := #0 +@5 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := fun (__v : @3) => @15 +@17 := LexLeanTarget.TargetSyntax.Value.nat +@18 := @17 @4 +@19 := LexLeanTarget.TargetSyntax.Ty.nat +@20 := LexLeanTarget.TargetSyntax.Program +@21 := LexLeanPreservation.Rust.RCrate +@22 := LexLeanPreservation.Rust.Flags +@23 := Nat +@24 := #3 +@25 := @7 @24 +@26 := #2 +@27 := @25 @26 +@28 := #1 +@35 := {p : @20} -> {c : @21} -> {A : @22} -> (n : @23) -> @27 @28 @18 @19 +@37 := LexLeanPreservation.Rust.wt_nat @0 +@44 := {c : @21} -> {A : @22} -> (n : @23) -> @11 @26 @28 @18 @19 +@45 := @37 @1 +@50 := {A : @22} -> (n : @23) -> @12 @28 @18 @19 +@51 := @45 @2 +@53 := @13 @18 @19 +@54 := (n : @23) -> @53 +@55 := @51 @4 +@56 := LexLeanTarget.TargetSyntax.Value +@57 := LexLeanTarget.TargetSyntax.Ty +@58 := List.nil.{0} +@59 := List.cons.{0} +@60 := @58 @56 +@61 := @59 @56 +@63 := @61 @18 @60 +@64 := @58 @57 +@65 := @59 @57 +@66 := @65 @19 +@67 := @66 @64 +@68 := LexLeanPreservation.Rust.WTL +@76 := {p : @20} -> {c : @21} -> {A : @22} -> @68 @26 @28 @4 @60 @64 +@78 := LexLeanPreservation.Rust.wtl_nil @0 +@79 := @68 @0 +@85 := {c : @21} -> {A : @22} -> @79 @28 @4 @60 @64 +@86 := @78 @1 +@87 := @79 @1 +@91 := {A : @22} -> @87 @4 @60 @64 +@92 := @86 @2 +@93 := @87 @2 +@94 := @93 @60 +@95 := @94 @64 +@96 := List.{0} +@97 := @96 @56 +@98 := @96 @57 +@99 := #6 +@100 := @7 @99 +@101 := #5 +@102 := @100 @101 +@103 := #4 +@106 := @102 @103 @24 @26 +@107 := #7 +@112 := @68 @107 @99 @101 @26 @28 +@113 := #8 +@116 := @68 @113 @107 @99 +@118 := @61 @101 @24 +@119 := @116 @118 +@121 := @65 @103 @26 +@131 := {p : @20} -> + {c : @21} -> + {A : @22} -> + {v : @56} -> {t : @57} -> {vs : @97} -> {ts : @98} -> (h : @106) -> (hs : @112) -> @119 @121 +@133 := LexLeanPreservation.Rust.wtl_cons @0 +@137 := @11 @101 @103 @24 @26 +@141 := @79 @99 @101 @26 @28 +@153 := {c : @21} -> + {A : @22} -> + {v : @56} -> + {t : @57} -> {vs : @97} -> {ts : @98} -> (h : @137) -> (hs : @141) -> @79 @107 @99 @118 @121 +@154 := @133 @1 +@157 := @12 @103 @24 @26 +@160 := @87 @101 @26 @28 +@170 := {A : @22} -> + {v : @56} -> + {t : @57} -> {vs : @97} -> {ts : @98} -> (h : @157) -> (hs : @160) -> @87 @99 @118 @121 +@171 := @154 @2 +@173 := @13 @24 @26 +@175 := @93 @26 @28 +@183 := {v : @56} -> + {t : @57} -> {vs : @97} -> {ts : @98} -> (h : @173) -> (hs : @175) -> @93 @118 @121 +@184 := @171 @18 +@185 := @17 @24 +@197 := {t : @57} -> + {vs : @97} -> {ts : @98} -> (h : @13 @185 @26) -> (hs : @175) -> @93 (@61 (@17 @101) @24) @121 +@198 := @184 @19 +@199 := @17 @26 +@201 := @13 @199 @19 +@205 := @93 (@61 (@17 @103) @24) +@206 := @66 @26 +@211 := {vs : @97} -> {ts : @98} -> (h : @201) -> (hs : @175) -> @205 @206 +@212 := @198 @60 +@213 := @17 @28 +@215 := @13 @213 @19 +@216 := @94 @28 +@218 := @61 @185 @60 +@223 := {ts : @98} -> (h : @215) -> (hs : @216) -> @93 @218 @206 +@224 := @212 @64 +@226 := @61 @199 @60 +@227 := @93 @226 +@230 := (h : @53) -> (hs : @95) -> @227 @67 +@231 := @224 @55 +@233 := @61 @213 @60 +@235 := @93 @233 @67 +@236 := (hs : @95) -> @235 +@237 := @231 @92 +@239 := @93 @63 @67 +@240 := Eq.{1} +@241 := Option.{0} +@242 := @241 @98 +@243 := @240 @242 +@244 := LexLeanPreservation.Rust.adtFields +@248 := @243 (@244 @99 @24 @26) +@249 := Option.some.{0} +@250 := @249 @98 +@251 := @250 @4 +@252 := @248 @251 +@255 := @7 @113 @107 @99 +@256 := LexLeanTarget.TargetSyntax.Value.adt +@258 := @256 @103 @24 +@259 := @255 @258 +@260 := @8 @101 +@270 := {p : @20} -> + {c : @21} -> + {A : @22} -> + {i : @23} -> {k : @23} -> {fs : @97} -> {tys : @98} -> (h : @252) -> (hf : @112) -> @259 @260 +@272 := LexLeanPreservation.Rust.wt_adt @0 +@273 := @244 @0 +@277 := @243 (@273 @24 @26) @251 +@289 := {c : @21} -> + {A : @22} -> + {i : @23} -> + {k : @23} -> {fs : @97} -> {tys : @98} -> (h : @277) -> (hf : @141) -> @11 @107 @99 @258 @260 +@290 := @272 @1 +@300 := {A : @22} -> + {i : @23} -> + {k : @23} -> {fs : @97} -> {tys : @98} -> (h : @277) -> (hf : @160) -> @12 @99 @258 @260 +@301 := @290 @2 +@302 := @13 @258 +@309 := {i : @23} -> + {k : @23} -> {fs : @97} -> {tys : @98} -> (h : @277) -> (hf : @175) -> @302 @260 +@310 := @301 @9 +@311 := @273 @9 +@320 := {k : @23} -> + {fs : @97} -> {tys : @98} -> (h : @243 (@311 @26) @251) -> (hf : @175) -> @302 @10 +@321 := @310 @9 +@322 := @311 @9 +@323 := @243 @322 +@324 := @323 @251 +@325 := @256 @9 +@332 := {fs : @97} -> {tys : @98} -> (h : @324) -> (hf : @175) -> @13 (@325 @24) @10 +@333 := @321 @63 +@340 := {tys : @98} -> (h : @324) -> (hf : @227 @28) -> @13 (@325 @218) @10 +@341 := @333 @67 +@348 := (h : @323 (@250 @67)) -> (hf : @235) -> @13 (@325 @226) @10 +@349 := Eq.refl.{1} +@350 := @349 @242 +@352 := @341 (@350 @322) +@356 := (hf : @239) -> @13 (@325 @233) @10 +@357 := @352 @237 +@360 := @13 (@325 @63) @10 +@361 := fun (__x0 : @23) => @357 +@362 := @5 @24 +@363 := @5 @26 +@365 := @61 @363 @60 +@366 := @61 @362 +@367 := @366 @365 +@368 := @65 @10 +@369 := @368 @64 +@370 := @368 @369 +@371 := @171 @363 +@372 := @5 @101 +@373 := @13 @372 +@374 := @373 @26 +@376 := @61 (@5 @107) +@378 := @93 (@376 @24) +@384 := {t : @57} -> {vs : @97} -> {ts : @98} -> (h : @374) -> (hs : @175) -> @378 @121 +@385 := @371 @10 +@386 := @5 @103 +@387 := @13 @386 +@388 := @387 @10 +@389 := @5 @99 +@390 := @61 @389 +@392 := @93 (@390 @24) +@393 := @368 @26 +@398 := {vs : @97} -> {ts : @98} -> (h : @388) -> (hs : @175) -> @392 @393 +@399 := @385 @60 +@401 := @13 @362 @10 +@402 := @61 @372 +@403 := @402 @60 +@404 := @93 @403 +@408 := {ts : @98} -> (h : @401) -> (hs : @216) -> @404 @393 +@409 := @399 @64 +@411 := @13 @363 @10 +@412 := @61 @386 +@413 := @412 @60 +@414 := @93 @413 +@417 := (h : @411) -> (hs : @95) -> @414 @369 +@418 := @409 @4 +@419 := @366 @60 +@420 := @93 @419 +@421 := @420 @369 +@422 := (hs : @95) -> @421 +@423 := @418 @92 +@424 := @93 @365 +@425 := @424 @369 +@426 := @171 @362 +@428 := @13 @389 @26 +@430 := @61 (@5 @113) +@438 := {t : @57} -> {vs : @97} -> {ts : @98} -> (h : @428) -> (hs : @175) -> @93 (@430 @24) @121 +@439 := @426 @10 +@445 := {vs : @97} -> {ts : @98} -> (h : @373 @10) -> (hs : @175) -> @378 @393 +@446 := @439 @365 +@447 := @414 @28 +@448 := @390 @403 +@453 := {ts : @98} -> (h : @388) -> (hs : @447) -> @93 @448 @393 +@454 := @446 @369 +@455 := @402 @413 +@456 := @93 @455 +@459 := (h : @401) -> (hs : @421) -> @456 @370 +@460 := @454 @28 +@461 := @412 @419 +@463 := @93 @461 @370 +@464 := (hs : @425) -> @463 +@465 := @460 @423 +@467 := @93 @367 @370 +@468 := 1 +@469 := @310 @468 +@470 := @311 @468 +@471 := @243 @470 +@472 := @471 @251 +@473 := @256 @468 +@480 := {fs : @97} -> {tys : @98} -> (h : @472) -> (hf : @175) -> @13 (@473 @24) @10 +@481 := @469 @367 +@488 := {tys : @98} -> (h : @472) -> (hf : @456 @28) -> @13 (@473 @448) @10 +@489 := @481 @370 +@496 := (h : @471 (@250 @370)) -> (hf : @463) -> @13 (@473 @455) @10 +@498 := @489 (@350 @470) +@502 := (hf : @467) -> @13 (@473 @461) @10 +@503 := @498 @465 +@506 := @13 (@473 @367) @10 +@507 := @5 @28 +@509 := @13 @507 @10 +@513 := fun (__x0 : @3) => fun (__x1 : @3) => fun (__ih0 : @509) => fun (__ih1 : @509) => @503 +@519 := fun (__v : @3) => Coverage.Syntax.Term.rec.{0} @16 @361 @513 @4 +@520 := (__v : @3) -> @15 +@522 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.__wt_0 @28 +@524 := @61 @507 @60 +@527 := Prod.{0, 0} @23 @56 +@531 := Prod.mk.{0, 0} @23 @56 @9 +@532 := @531 @507 +@533 := @58 @527 +@534 := @59 @527 +@536 := @534 @532 @533 +@537 := Bool.false +@538 := LexLeanTarget.TargetSyntax.Function +@539 := LexLeanTarget.TargetSyntax.Program.functions +@540 := @539 @0 +@541 := @58 @23 +@542 := LexLeanTarget.TargetSyntax.Ty.unit +@543 := LexLeanTarget.TargetSyntax.Value.unit +@546 := LexLeanTarget.TargetSyntax.Expr.value @542 @543 +@551 := LexLeanTarget.TargetSyntax.Function.mk @541 @64 @542 @546 +@556 := List.getD.{0} @538 @540 @9 @551 +@560 := fun (__e_n : @23) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.root @4 @9 +@561 := @171 @507 +@568 := {t : @57} -> {vs : @97} -> {ts : @98} -> (h : @387 @26) -> (hs : @175) -> @392 @121 +@569 := @561 @10 +@576 := {vs : @97} -> {ts : @98} -> (h : @401) -> (hs : @175) -> @93 (@402 @24) @393 +@577 := @569 @60 +@581 := {ts : @98} -> (h : @411) -> (hs : @216) -> @414 @393 +@582 := @577 @64 +@583 := (h : @509) -> @422 +@584 := @582 @522 +@585 := (hs : @95) -> @425 +@586 := @584 @92 +@587 := @93 @524 +@588 := @587 @369 +@589 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.denote +@590 := @589 @28 +@591 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.__fits_0 +@592 := @591 @28 +@594 := Coverage.RecRoots.rewrite @28 +@600 := LexLeanPreservation.encPair @3 @3 @5 @5 @594 +@602 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.root @28 +@603 := Bool +@604 := Ne.{1} +@605 := LexLeanPreservation.Obs +@606 := @604 @605 +@607 := LexLeanPreservation.Rel +@610 := @606 (@607 @28 @4) +@611 := LexLeanPreservation.Obs.stuck +@614 := (f : @603) -> (v : @56) -> @610 @611 +@616 := LexLeanPreservation.Rust.rel_ne_stuck @592 +@622 := (v : @56) -> @606 (@607 (@591 @26) @4) @611 +@623 := @616 @600 +@627 := @606 (@607 @592 @600) @611 +@628 := @96 @527 +@629 := LexLeanPreservation.Rust.FunSem +@630 := #9 +@636 := (n : @23) -> @629 @630 @113 @107 @4 @99 +@637 := @241 @538 +@638 := @240 @637 +@645 := LexLeanRuntime.index (@96 @538) @538 (LexLeanRuntime.instIndexableList @538) +@649 := @638 (@645 (@539 @630) @99) +@650 := @249 @538 +@651 := @650 @101 +@652 := @649 @651 +@653 := #10 +@657 := @68 @653 @630 @113 @101 +@658 := LexLeanTarget.TargetSyntax.Function.types +@659 := @658 @99 +@660 := @657 @659 +@661 := @241 @628 +@662 := @240 @661 +@663 := LexLeanTarget.TargetSemantics.bindAll +@664 := LexLeanTarget.TargetSyntax.Function.parameters +@669 := @662 (@663 (@664 @107) @99 @533) +@670 := @249 @628 +@671 := @670 @101 +@672 := @669 @671 +@673 := @241 @603 +@674 := @240 @673 +@675 := LexLeanPreservation.Rust.fnFallible +@676 := #11 +@679 := @674 (@675 @676 @630) +@680 := @249 @603 +@681 := @680 @101 +@682 := @679 @681 +@683 := LexLeanPreservation.RunConv +@684 := #13 +@688 := @683 @684 @653 @113 @101 +@690 := @606 @99 @611 +@691 := Exists.{1} +@692 := LexLeanPreservation.Rust.ROut +@693 := @691 @692 +@694 := And +@695 := LexLeanPreservation.Rust.RealizesFn +@699 := @694 (@695 @630 @113 @4) +@700 := LexLeanPreservation.Rust.RCI +@702 := @700 #15 +@703 := LexLeanPreservation.Rust.fnIdent +@704 := @703 @684 +@711 := (hne : @690) -> @693 (fun (ro : @692) => @699 (@702 @704 @676 @4)) +@726 := {p : @20} -> + {c : @21} -> + {A : @22} -> + {f : @23} -> + {fn : @538} -> + {args : @97} -> + {env : @628} -> + {F : @603} -> + {o : @605} -> + (hB : @636) -> + (hfn : @652) -> (hwt : @660) -> (hbind : @672) -> (hF : @682) -> (hA : @688) -> @711 +@728 := LexLeanPreservation.Rust.compose @0 +@729 := @629 @0 +@734 := (n : @23) -> @729 @113 @107 @4 @99 +@735 := @645 @540 +@738 := @638 (@735 @99) @651 +@742 := @79 @630 @113 @101 @659 +@743 := @683 @0 +@746 := @743 @653 @113 @101 +@760 := {c : @21} -> + {A : @22} -> + {f : @23} -> + {fn : @538} -> + {args : @97} -> + {env : @628} -> + {F : @603} -> + {o : @605} -> + (hB : @734) -> + (hfn : @738) -> (hwt : @742) -> (hbind : @672) -> (hF : @682) -> (hA : @746) -> @711 +@761 := @728 @1 +@762 := @729 @1 +@766 := (n : @23) -> @762 @107 @4 @99 +@769 := @87 @113 @101 @659 +@770 := @675 @1 +@773 := @674 (@770 @630) @681 +@774 := @700 @1 +@784 := (hbind : @672) -> + (hF : @773) -> (hA : @746) -> (hne : @690) -> @693 (fun (ro : @692) => @699 (@774 @704 @676 @4)) +@794 := {A : @22} -> + {f : @23} -> + {fn : @538} -> + {args : @97} -> + {env : @628} -> {F : @603} -> {o : @605} -> (hB : @766) -> (hfn : @738) -> (hwt : @769) -> @784 +@795 := @761 @2 +@797 := @762 @2 @4 +@799 := (n : @23) -> @797 @99 +@800 := @93 @101 +@801 := @800 @659 +@810 := {f : @23} -> + {fn : @538} -> + {args : @97} -> + {env : @628} -> {F : @603} -> {o : @605} -> (hB : @799) -> (hfn : @738) -> (hwt : @801) -> @784 +@811 := @795 @9 +@813 := (n : @23) -> @797 @9 +@814 := @735 @9 +@815 := @638 @814 +@816 := @815 @651 +@817 := @770 @9 +@818 := @674 @817 +@819 := @818 @681 +@820 := @743 @9 +@822 := @820 @113 @101 +@824 := @774 (@703 @9) +@832 := (hF : @819) -> (hA : @822) -> (hne : @690) -> @693 (fun (ro : @692) => @699 (@824 @676 @4)) +@841 := {fn : @538} -> + {args : @97} -> + {env : @628} -> + {F : @603} -> {o : @605} -> (hB : @813) -> (hfn : @816) -> (hwt : @801) -> (hbind : @672) -> @832 +@842 := @811 @556 +@844 := @815 (@650 @556) +@845 := @658 @556 +@846 := @800 @845 +@848 := @663 (@664 @556) +@860 := {args : @97} -> + {env : @628} -> + {F : @603} -> + {o : @605} -> + (hB : @813) -> (hfn : @844) -> (hwt : @846) -> (hbind : @662 (@848 @99 @533) @671) -> @832 +@861 := @842 @524 +@862 := @390 @60 +@864 := @93 @862 @845 +@865 := @376 @60 +@869 := @662 (@848 @865 @533) @671 +@872 := @61 (@5 @630) @60 +@893 := {env : @628} -> + {F : @603} -> + {o : @605} -> + (hB : @813) -> + (hfn : @844) -> + (hwt : @864) -> + (hbind : @869) -> + (hF : @819) -> + (hA : @820 @872 @101) -> + (hne : @690) -> @693 (fun (ro : @692) => @699 (@824 (@61 (@5 #12) @60) @4)) +@894 := @861 @536 +@895 := @404 @845 +@903 := @662 (@848 @862 @533) (@670 (@534 (@531 @389) @533)) +@904 := @430 @60 +@923 := {F : @603} -> + {o : @605} -> + (hB : @813) -> + (hfn : @844) -> + (hwt : @895) -> + (hbind : @903) -> + (hF : @819) -> + (hA : @820 @904 @101) -> + (hne : @690) -> @693 (fun (ro : @692) => @699 (@824 (@61 (@5 @676) @60) @4)) +@924 := @894 @537 +@925 := @414 @845 +@933 := @662 (@848 @403 @533) (@670 (@534 (@531 @372) @533)) +@935 := @818 (@680 @537) +@937 := @820 @865 @101 +@938 := @695 @537 +@957 := {o : @605} -> + (hB : @813) -> + (hfn : @844) -> + (hwt : @925) -> + (hbind : @933) -> + (hF : @935) -> + (hA : @937) -> + (hne : @690) -> @693 (fun (ro : @692) => @694 (@938 @113 @4) (@824 (@61 (@5 @653) @60) @4)) +@958 := @924 @590 +@959 := @420 @845 +@967 := @662 (@848 @413 @533) (@670 (@534 (@531 @386) @533)) +@968 := @820 @862 +@969 := @589 @99 +@970 := @968 @969 +@971 := @589 @107 +@989 := (hB : @813) -> + (hfn : @844) -> + (hwt : @959) -> + (hbind : @967) -> + (hF : @935) -> + (hA : @970) -> + (hne : @606 @971 @611) -> @693 (fun (ro : @692) => @694 (@938 (@589 @630) @4) (@824 @872 @4)) +@990 := @958 @560 +@991 := @424 @845 +@999 := @662 (@848 @419 @533) (@670 (@534 (@531 @362) @533)) +@1000 := @820 @403 +@1001 := @589 @101 +@1019 := (hfn : @844) -> + (hwt : @991) -> + (hbind : @999) -> + (hF : @935) -> + (hA : @1000 @1001) -> + (hne : @606 @969 @611) -> @693 (fun (ro : @692) => @694 (@938 (@589 @113) @4) (@824 @904 @4)) +@1022 := @990 (@349 @637 @814) +@1023 := @587 @845 +@1031 := @662 (@848 @365 @533) (@670 (@534 (@531 @363) @533)) +@1032 := @820 @413 +@1033 := @589 @103 +@1049 := (hwt : @1023) -> + (hbind : @1031) -> + (hF : @935) -> + (hA : @1032 @1033) -> + (hne : @606 @1001 @611) -> @693 (fun (ro : @692) => @694 (@938 @971 @4) (@824 @865 @4)) +@1050 := @1022 @586 +@1052 := @848 @524 @533 +@1055 := @662 @1052 (@670 @536) +@1056 := @820 @419 +@1057 := @589 @24 +@1072 := (hbind : @1055) -> + (hF : @935) -> + (hA : @1056 @1057) -> + (hne : @606 @1033 @611) -> @693 (fun (ro : @692) => @694 (@938 @969 @4) (@824 @862 @4)) +@1075 := @1050 (@349 @661 @1052) +@1076 := @820 @365 +@1077 := @589 @26 +@1091 := (hF : @935) -> + (hA : @1076 @1077) -> + (hne : @606 @1057 @611) -> @693 (fun (ro : @692) => @694 (@938 @1001 @4) (@824 @403 @4)) +@1094 := @1075 (@349 @673 @817) +@1108 := (hA : @820 @524 @590) -> + (hne : @606 @1077 @611) -> @693 (fun (ro : @692) => @694 (@938 @1033 @4) (@824 @413 @4)) +@1109 := @1094 @602 +@1120 := (hne : @606 @590 @611) -> @693 (fun (ro : @692) => @694 (@938 @1057 @4) (@824 @419 @4)) +@1121 := @1109 @623 +@1127 := @694 (@938 @1077 @4) (@824 @365 @4) +@1129 := @693 (fun (ro : @692) => @1127) +@1131 := @693 (fun (__e_ro : @692) => @1127) +@1135 := LexLeanPreservation.Rust.RepresentableL (@61 @6 @60) +@1136 := (__e_hrep : @1135) -> @1131 +@1137 := fun (__e_hrep : @1135) => @1121 +@1138 := (t : @3) -> @1136 +@1139 := fun (t : @3) => @1137 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R4/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R4/Compose/RustStd.lean deleted file mode 100644 index 718e62ddd..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R4/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd - -/-- The rendering of the root's entry, invoked on the encoded arguments, -realizes the encoded source result when the arguments satisfy §17.12's -invariants, and refuses them with `none` otherwise. -/ -theorem root (xs : (List Nat)) (s : (List Int)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) xs), ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.int) s)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 6) [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) xs), ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.int) s)] __e_ro ∧ - (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.accepts xs s → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.denote xs s)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.accepts xs s → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none) __e_ro) := - match _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd.root __e_n 6) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat) xs) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_int) s) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.entry xs s) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) with - | ⟨__e_ro, __e_hr, __e_hc⟩ => ⟨__e_ro, __e_hc, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.entry_accepts xs s __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.entry_refuses xs s __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R4/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R4/Compose/RustStd.lex.tex new file mode 100644 index 000000000..a4c539cdb --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R4/Compose/RustStd.lex.tex @@ -0,0 +1,606 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd.root : @1228 := @1229 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd.flags +@3 := Nat +@4 := List.{0} +@5 := @4 @3 +@6 := #2 +@7 := LexLeanTarget.TargetSyntax.Value.nat +@8 := LexLeanPreservation.encList +@9 := @8 @3 +@10 := @9 @7 +@11 := @10 @6 +@12 := LexLeanTarget.TargetSyntax.Ty.nat +@13 := LexLeanTarget.TargetSyntax.Ty.list +@14 := @13 @12 +@15 := #0 +@16 := LexLeanTarget.TargetSyntax.Program +@17 := LexLeanPreservation.Rust.RCrate +@18 := LexLeanPreservation.Rust.Flags +@19 := LexLeanPreservation.Rust.WT +@20 := #3 +@22 := @19 @20 @6 +@23 := #1 +@24 := @22 @23 +@25 := @7 @15 +@31 := {p : @16} -> {c : @17} -> {A : @18} -> (n : @3) -> @24 @25 @12 +@33 := LexLeanPreservation.Rust.wt_nat @0 +@34 := @19 @0 +@36 := @34 @6 @23 +@41 := {c : @17} -> {A : @18} -> (n : @3) -> @36 @25 @12 +@42 := @33 @1 +@43 := @34 @1 +@44 := @43 @23 +@48 := {A : @18} -> (n : @3) -> @44 @25 @12 +@49 := @42 @2 +@50 := @43 @2 +@51 := @50 @25 +@52 := @51 @12 +@53 := (n : @3) -> @52 +@55 := fun (__x : @3) => @49 @15 +@56 := Sort 1 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := (a._@._internal._hyg.#0 : @15) -> @57 +@59 := LexLeanTarget.TargetSyntax.Ty +@60 := #6 +@61 := @19 @60 +@62 := #5 +@63 := @61 @62 +@64 := #4 +@65 := @63 @64 +@66 := @6 @15 +@69 := (x : @6) -> @65 @66 @23 +@70 := @4 @20 +@71 := #7 +@74 := @19 @71 @60 @62 +@77 := @8 @64 @20 @15 +@78 := @74 @77 +@79 := @13 @6 +@88 := {p : @16} -> + {c : @17} -> + {A : @18} -> {α : @56} -> {e : @58} -> {t : @59} -> (h : @69) -> (xs : @70) -> @78 @79 +@90 := LexLeanPreservation.Rust.wt_encList @0 +@92 := @34 @62 @64 +@106 := {c : @17} -> + {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @6) -> @92 @66 @23) -> (xs : @70) -> @34 @60 @62 @77 @79 +@107 := @90 @1 +@108 := @43 @64 +@120 := {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @6) -> @108 @66 @23) -> (xs : @70) -> @43 @62 @77 @79 +@121 := @107 @2 +@123 := @50 @66 @23 +@131 := {α : @56} -> {e : @58} -> {t : @59} -> (h : (x : @6) -> @123) -> (xs : @70) -> @50 @77 @79 +@132 := @121 @3 +@142 := {e : (a._@._internal._hyg.#0 : @3) -> @57} -> + {t : @59} -> (h : (x : @3) -> @123) -> (xs : @5) -> @50 (@9 @20 @15) @79 +@143 := @132 @7 +@145 := (x : @3) -> @51 @23 +@147 := @50 (@10 @15) +@151 := {t : @59} -> (h : @145) -> (xs : @5) -> @147 @79 +@152 := @143 @12 +@156 := (h : (x : @3) -> @52) -> (xs : @5) -> @147 @14 +@158 := @152 @55 @6 +@160 := @50 @11 @14 +@161 := Int +@162 := @4 @161 +@163 := LexLeanTarget.TargetSyntax.Value.int +@164 := @8 @161 +@165 := @164 @163 +@166 := @165 @23 +@167 := LexLeanTarget.TargetSyntax.Ty.int +@168 := @13 @167 +@169 := @163 @15 +@175 := {p : @16} -> {c : @17} -> {A : @18} -> (n : @161) -> @24 @169 @167 +@177 := LexLeanPreservation.Rust.wt_int @0 +@182 := {c : @17} -> {A : @18} -> (n : @161) -> @36 @169 @167 +@183 := @177 @1 +@187 := {A : @18} -> (n : @161) -> @44 @169 @167 +@188 := @183 @2 +@189 := @50 @169 +@190 := @189 @167 +@191 := (n : @161) -> @190 +@193 := fun (__x : @161) => @188 @15 +@194 := @121 @161 +@204 := {e : (a._@._internal._hyg.#0 : @161) -> @57} -> + {t : @59} -> (h : (x : @161) -> @123) -> (xs : @162) -> @50 (@164 @20 @15) @79 +@205 := @194 @163 +@207 := (x : @161) -> @189 @23 +@208 := @165 @15 +@209 := @50 @208 +@213 := {t : @59} -> (h : @207) -> (xs : @162) -> @209 @79 +@214 := @205 @167 +@218 := (h : (x : @161) -> @190) -> (xs : @162) -> @209 @168 +@220 := @214 @193 @23 +@222 := @50 @166 @168 +@223 := List.nil.{0} +@224 := List.cons.{0} +@225 := @223 @57 +@226 := @224 @57 +@228 := @226 @166 @225 +@230 := @226 @11 @228 +@233 := Prod.{0, 0} @3 @57 +@234 := 1 +@237 := Prod.mk.{0, 0} @3 @57 +@238 := @237 @234 +@239 := @238 @166 +@241 := @237 0 +@242 := @241 @11 +@243 := @223 @233 +@244 := @224 @233 +@246 := @244 @242 @243 +@248 := @244 @239 @246 +@249 := Bool.true +@250 := LexLeanTarget.TargetSyntax.Function +@251 := LexLeanTarget.TargetSyntax.Program.functions +@252 := @251 @0 +@253 := 6 +@254 := @223 @3 +@255 := @223 @59 +@256 := LexLeanTarget.TargetSyntax.Ty.unit +@257 := LexLeanTarget.TargetSyntax.Value.unit +@260 := LexLeanTarget.TargetSyntax.Expr.value @256 @257 +@265 := LexLeanTarget.TargetSyntax.Function.mk @254 @255 @256 @260 +@270 := List.getD.{0} @250 @252 @253 @265 +@274 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd.root @15 @253 +@275 := LexLeanPreservation.Rust.WTL +@283 := {p : @16} -> {c : @17} -> {A : @18} -> @275 @6 @23 @15 @225 @255 +@285 := LexLeanPreservation.Rust.wtl_nil @0 +@286 := @275 @0 +@292 := {c : @17} -> {A : @18} -> @286 @23 @15 @225 @255 +@293 := @285 @1 +@294 := @286 @1 +@298 := {A : @18} -> @294 @15 @225 @255 +@299 := @293 @2 +@300 := @294 @2 +@301 := @300 @225 +@302 := @301 @255 +@303 := @4 @57 +@304 := @4 @59 +@306 := @65 @20 @6 +@311 := @275 @71 @60 @62 @6 @23 +@312 := #8 +@315 := @275 @312 @71 @60 +@317 := @226 @62 @20 +@318 := @315 @317 +@319 := @224 @59 +@321 := @319 @64 @6 +@331 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {v : @57} -> {t : @59} -> {vs : @303} -> {ts : @304} -> (h : @306) -> (hs : @311) -> @318 @321 +@333 := LexLeanPreservation.Rust.wtl_cons @0 +@351 := {c : @17} -> + {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @303} -> + {ts : @304} -> (h : @92 @20 @6) -> (hs : @286 @60 @62 @6 @23) -> @286 @71 @60 @317 @321 +@352 := @333 @1 +@367 := {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @303} -> {ts : @304} -> (h : @108 @20 @6) -> (hs : @294 @62 @6 @23) -> @294 @60 @317 @321 +@368 := @352 @2 +@370 := @50 @20 @6 +@372 := @300 @6 @23 +@380 := {v : @57} -> + {t : @59} -> {vs : @303} -> {ts : @304} -> (h : @370) -> (hs : @372) -> @300 @317 @321 +@381 := @368 @166 +@382 := @165 @64 +@384 := @50 @382 @6 +@385 := @165 @60 +@386 := @226 @385 +@394 := {t : @59} -> {vs : @303} -> {ts : @304} -> (h : @384) -> (hs : @372) -> @300 (@386 @20) @321 +@395 := @381 @168 +@396 := @165 @20 +@398 := @50 @396 @168 +@399 := @165 @62 +@400 := @226 @399 +@402 := @300 (@400 @20) +@403 := @319 @168 +@404 := @403 @6 +@409 := {vs : @303} -> {ts : @304} -> (h : @398) -> (hs : @372) -> @402 @404 +@410 := @395 @225 +@411 := @165 @6 +@413 := @50 @411 @168 +@414 := @301 @23 +@416 := @226 @382 @225 +@421 := {ts : @304} -> (h : @413) -> (hs : @414) -> @300 @416 @404 +@422 := @410 @255 +@424 := @226 @396 @225 +@425 := @300 @424 +@426 := @403 @255 +@429 := (h : @222) -> (hs : @302) -> @425 @426 +@430 := @422 @220 +@432 := @226 @411 @225 +@434 := @300 @432 @426 +@435 := (hs : @302) -> @434 +@436 := @430 @299 +@438 := @300 @228 @426 +@439 := @368 @11 +@440 := @10 @62 +@442 := @50 @440 @6 +@443 := @10 @71 +@444 := @226 @443 +@452 := {t : @59} -> {vs : @303} -> {ts : @304} -> (h : @442) -> (hs : @372) -> @300 (@444 @20) @321 +@453 := @439 @14 +@454 := @10 @64 +@456 := @50 @454 @14 +@457 := @10 @60 +@458 := @226 @457 +@460 := @300 (@458 @20) +@461 := @319 @14 +@462 := @461 @6 +@467 := {vs : @303} -> {ts : @304} -> (h : @456) -> (hs : @372) -> @460 @462 +@468 := @453 @228 +@469 := @10 @20 +@471 := @50 @469 @14 +@472 := @425 @23 +@474 := @226 @440 @416 +@475 := @300 @474 +@479 := {ts : @304} -> (h : @471) -> (hs : @472) -> @475 @462 +@480 := @468 @426 +@482 := @226 @454 @424 +@483 := @300 @482 +@484 := @461 @426 +@487 := (h : @160) -> (hs : @434) -> @483 @484 +@488 := @480 @158 +@490 := @226 @469 @432 +@491 := @300 @490 +@493 := (hs : @438) -> @491 @484 +@494 := @488 @436 +@495 := @300 @230 +@496 := @495 @484 +@497 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.denoteEntry +@499 := @497 @6 @23 +@500 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.entryFits +@502 := @500 @6 @23 +@505 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.entryValue @6 @23 +@508 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.entry @6 @23 +@509 := Bool +@510 := Ne.{1} +@511 := LexLeanPreservation.Obs +@512 := @510 @511 +@513 := LexLeanPreservation.Rel +@516 := @512 (@513 @23 @15) +@517 := LexLeanPreservation.Obs.stuck +@520 := (f : @509) -> (v : @57) -> @516 @517 +@522 := LexLeanPreservation.Rust.rel_ne_stuck @502 +@529 := (v : @57) -> @512 (@513 (@500 @20 @6) @15) @517 +@530 := @522 @505 +@534 := @512 (@513 @502 @505) @517 +@535 := @4 @233 +@536 := LexLeanPreservation.Rust.FunSem +@537 := #9 +@543 := (n : @3) -> @536 @537 @312 @71 @15 @60 +@544 := Eq.{1} +@545 := Option.{0} +@546 := @545 @250 +@547 := @544 @546 +@554 := LexLeanRuntime.index (@4 @250) @250 (LexLeanRuntime.instIndexableList @250) +@558 := @547 (@554 (@251 @537) @60) +@559 := Option.some.{0} +@560 := @559 @250 +@561 := @560 @62 +@562 := @558 @561 +@563 := #10 +@567 := @275 @563 @537 @312 @62 +@568 := LexLeanTarget.TargetSyntax.Function.types +@569 := @568 @60 +@570 := @567 @569 +@571 := @545 @535 +@572 := @544 @571 +@573 := LexLeanTarget.TargetSemantics.bindAll +@574 := LexLeanTarget.TargetSyntax.Function.parameters +@579 := @572 (@573 (@574 @71) @60 @243) +@580 := @559 @535 +@581 := @580 @62 +@582 := @579 @581 +@583 := @545 @509 +@584 := @544 @583 +@585 := LexLeanPreservation.Rust.fnFallible +@586 := #11 +@589 := @584 (@585 @586 @537) +@590 := @559 @509 +@591 := @590 @62 +@592 := @589 @591 +@593 := LexLeanPreservation.RunConv +@594 := #13 +@598 := @593 @594 @563 @312 @62 +@600 := @512 @60 @517 +@601 := Exists.{1} +@602 := LexLeanPreservation.Rust.ROut +@603 := @601 @602 +@604 := And +@605 := LexLeanPreservation.Rust.RealizesFn +@609 := @604 (@605 @537 @312 @15) +@610 := LexLeanPreservation.Rust.RCI +@612 := @610 #15 +@613 := LexLeanPreservation.Rust.fnIdent +@614 := @613 @594 +@621 := (hne : @600) -> @603 (fun (ro : @602) => @609 (@612 @614 @586 @15)) +@636 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @250} -> + {args : @303} -> + {env : @535} -> + {F : @509} -> + {o : @511} -> + (hB : @543) -> + (hfn : @562) -> (hwt : @570) -> (hbind : @582) -> (hF : @592) -> (hA : @598) -> @621 +@638 := LexLeanPreservation.Rust.compose @0 +@639 := @536 @0 +@644 := (n : @3) -> @639 @312 @71 @15 @60 +@645 := @554 @252 +@648 := @547 (@645 @60) @561 +@652 := @286 @537 @312 @62 @569 +@653 := @593 @0 +@656 := @653 @563 @312 @62 +@670 := {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @250} -> + {args : @303} -> + {env : @535} -> + {F : @509} -> + {o : @511} -> + (hB : @644) -> + (hfn : @648) -> (hwt : @652) -> (hbind : @582) -> (hF : @592) -> (hA : @656) -> @621 +@671 := @638 @1 +@672 := @639 @1 +@676 := (n : @3) -> @672 @71 @15 @60 +@679 := @294 @312 @62 @569 +@680 := @585 @1 +@683 := @584 (@680 @537) @591 +@684 := @610 @1 +@694 := (hbind : @582) -> + (hF : @683) -> (hA : @656) -> (hne : @600) -> @603 (fun (ro : @602) => @609 (@684 @614 @586 @15)) +@704 := {A : @18} -> + {f : @3} -> + {fn : @250} -> + {args : @303} -> + {env : @535} -> {F : @509} -> {o : @511} -> (hB : @676) -> (hfn : @648) -> (hwt : @679) -> @694 +@705 := @671 @2 +@707 := @672 @2 @15 +@709 := (n : @3) -> @707 @60 +@710 := @300 @62 +@711 := @710 @569 +@720 := {f : @3} -> + {fn : @250} -> + {args : @303} -> + {env : @535} -> {F : @509} -> {o : @511} -> (hB : @709) -> (hfn : @648) -> (hwt : @711) -> @694 +@721 := @705 @253 +@723 := (n : @3) -> @707 @253 +@724 := @645 @253 +@725 := @547 @724 +@726 := @725 @561 +@727 := @680 @253 +@728 := @584 @727 +@729 := @728 @591 +@730 := @653 @253 +@732 := @730 @312 @62 +@734 := @684 (@613 @253) +@742 := (hF : @729) -> (hA : @732) -> (hne : @600) -> @603 (fun (ro : @602) => @609 (@734 @586 @15)) +@751 := {fn : @250} -> + {args : @303} -> + {env : @535} -> + {F : @509} -> {o : @511} -> (hB : @723) -> (hfn : @726) -> (hwt : @711) -> (hbind : @582) -> @742 +@752 := @721 @270 +@754 := @725 (@560 @270) +@755 := @568 @270 +@756 := @710 @755 +@758 := @573 (@574 @270) +@770 := {args : @303} -> + {env : @535} -> + {F : @509} -> + {o : @511} -> + (hB : @723) -> (hfn : @754) -> (hwt : @756) -> (hbind : @572 (@758 @60 @243) @581) -> @742 +@771 := @752 @230 +@773 := @444 (@386 @225) +@775 := @300 @773 @755 +@781 := @226 (@10 @312) (@226 (@165 @71) @225) +@785 := @572 (@758 @781 @243) @581 +@791 := @226 (@10 @563) (@226 (@165 @537) @225) +@793 := @730 @791 @62 +@795 := @226 (@10 @594) +@796 := #12 +@815 := {env : @535} -> + {F : @509} -> + {o : @511} -> + (hB : @723) -> + (hfn : @754) -> + (hwt : @775) -> + (hbind : @785) -> + (hF : @729) -> + (hA : @793) -> + (hne : @600) -> @603 (fun (ro : @602) => @609 (@734 (@795 (@226 (@165 @796) @225)) @15)) +@816 := @771 @248 +@818 := @458 (@400 @225) +@820 := @300 @818 @755 +@831 := @572 (@758 @773 @243) (@580 (@244 (@238 @385) (@244 (@241 @443) @243))) +@837 := @226 (@10 @537) (@226 (@165 @312) @225) +@859 := {F : @509} -> + {o : @511} -> + (hB : @723) -> + (hfn : @754) -> + (hwt : @820) -> + (hbind : @831) -> + (hF : @729) -> + (hA : @730 @837 @62) -> + (hne : @600) -> + @603 (fun (ro : @602) => @609 (@734 (@226 (@10 @796) (@226 (@165 @586) @225)) @15)) +@860 := @816 @249 +@861 := @475 @755 +@872 := @572 (@758 @818 @243) (@580 (@244 (@238 @399) (@244 (@241 @457) @243))) +@874 := @728 (@590 @249) +@876 := @730 @781 @62 +@877 := @605 @249 +@899 := {o : @511} -> + (hB : @723) -> + (hfn : @754) -> + (hwt : @861) -> + (hbind : @872) -> + (hF : @874) -> + (hA : @876) -> + (hne : @600) -> + @603 + (fun (ro : @602) => @604 (@877 @312 @15) (@734 (@226 (@10 @586) (@226 (@165 @563) @225)) @15)) +@900 := @860 @499 +@901 := @483 @755 +@912 := @572 (@758 @474 @243) (@580 (@244 (@238 @382) (@244 (@241 @440) @243))) +@913 := @730 @773 +@915 := @497 @71 @60 +@916 := @913 @915 +@918 := @497 @312 @71 +@937 := (hB : @723) -> + (hfn : @754) -> + (hwt : @901) -> + (hbind : @912) -> + (hF : @874) -> + (hA : @916) -> + (hne : @512 @918 @517) -> + @603 (fun (ro : @602) => @604 (@877 (@497 @563 @537) @15) (@734 @791 @15)) +@938 := @900 @274 +@939 := @491 @755 +@950 := @572 (@758 @482 @243) (@580 (@244 (@238 @396) (@244 (@241 @454) @243))) +@951 := @730 @818 +@953 := @497 @60 @62 +@972 := (hfn : @754) -> + (hwt : @939) -> + (hbind : @950) -> + (hF : @874) -> + (hA : @951 @953) -> + (hne : @512 @915 @517) -> + @603 (fun (ro : @602) => @604 (@877 (@497 @537 @312) @15) (@734 @837 @15)) +@973 := Eq.refl.{1} +@976 := @938 (@973 @546 @724) +@977 := @495 @755 +@988 := @572 (@758 @490 @243) (@580 (@244 (@238 @411) (@244 (@241 @469) @243))) +@989 := @730 @474 +@991 := @497 @62 @64 +@1007 := (hwt : @977) -> + (hbind : @988) -> + (hF : @874) -> + (hA : @989 @991) -> + (hne : @512 @953 @517) -> @603 (fun (ro : @602) => @604 (@877 @918 @15) (@734 @781 @15)) +@1008 := @976 @494 +@1010 := @758 @230 @243 +@1013 := @572 @1010 (@580 @248) +@1014 := @730 @482 +@1016 := @497 @64 @20 +@1031 := (hbind : @1013) -> + (hF : @874) -> + (hA : @1014 @1016) -> + (hne : @512 @991 @517) -> @603 (fun (ro : @602) => @604 (@877 @915 @15) (@734 @773 @15)) +@1034 := @1008 (@973 @571 @1010) +@1035 := @730 @490 +@1037 := @497 @20 @6 +@1051 := (hF : @874) -> + (hA : @1035 @1037) -> + (hne : @512 @1016 @517) -> @603 (fun (ro : @602) => @604 (@877 @953 @15) (@734 @818 @15)) +@1054 := @1034 (@973 @583 @727) +@1056 := @730 @230 @499 +@1058 := @512 @1037 @517 +@1059 := @877 @991 +@1061 := @604 (@1059 @15) +@1062 := @734 @474 +@1063 := @1062 @15 +@1068 := (hA : @1056) -> (hne : @1058) -> @603 (fun (ro : @602) => @1061 @1063) +@1069 := @1054 @508 +@1071 := @512 @499 @517 +@1072 := @877 @1016 +@1074 := @604 (@1072 @15) +@1075 := @734 @482 +@1080 := (hne : @1071) -> @603 (fun (ro : @602) => @1074 (@1075 @15)) +@1081 := @1069 @530 +@1084 := @604 (@877 @1037 @15) +@1086 := @734 @490 @15 +@1087 := @1084 @1086 +@1089 := @603 (fun (ro : @602) => @1087) +@1090 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.accepts +@1092 := @1090 @6 @23 +@1093 := LexLeanPreservation.someObs +@1094 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.denote +@1097 := @1093 (@1094 @6 @23) +@1100 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none +@1101 := Not +@1102 := @1101 @1092 +@1104 := @1090 @20 @6 +@1107 := @1093 (@1094 @20 @6) +@1108 := @1101 @1104 +@1114 := @1104 -> @877 (@1093 (@1094 @64 @20)) @23 +@1115 := @877 @1100 +@1116 := @1115 @23 +@1117 := @1108 -> @1116 +@1119 := @604 @1114 @1117 +@1123 := @603 (fun (__e_ro : @602) => @604 @1086 @1119) +@1124 := fun (__e_ro : @602) => @1087 +@1125 := @1072 @23 +@1126 := @1075 @23 +@1127 := And.left +@1128 := And.right +@1131 := @1127 @1125 @1126 @15 +@1134 := @1128 @1125 @1126 @15 +@1135 := @877 @15 +@1137 := fun (__e_o : @511) => @1135 @6 +@1138 := Eq.subst.{1} +@1140 := @1090 @64 @20 +@1141 := @1101 @1140 +@1145 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.entry_accepts @62 @64 @15 +@1148 := @1093 (@1094 @62 @64) +@1153 := @1127 (@1059 @6) (@1062 @6) @23 +@1155 := fun (__e_o : @511) => @1135 @20 +@1158 := @1138 @511 @1155 @991 +@1162 := fun (__e_h : @1140) => @1158 @1148 @1145 @1153 +@1166 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.entry_refuses @62 @64 @15 +@1170 := fun (__e_h : @1141) => @1158 @1100 @1166 @1153 +@1171 := And.intro +@1174 := @1140 -> @877 @1148 @6 +@1176 := @1141 -> @1115 @6 +@1178 := @604 @1174 @1176 +@1182 := @1171 @1174 @1176 @1162 @1170 +@1186 := @1171 @1126 @1178 @1134 @1182 +@1187 := Exists.intro.{1} +@1188 := @604 @1063 +@1190 := @1090 @62 @64 +@1202 := fun (__e_ro : @602) => + @1188 (@604 (@1190 -> @877 (@1093 (@1094 @60 @62)) @23) (@1101 @1190 -> @1116)) +@1206 := @1187 @602 @1202 @23 @1186 +@1208 := @604 @1125 @1126 +@1210 := fun (__e_ro : @602) => fun (__e_hand : @1087) => @1206 +@1216 := Exists.elim.{1} @602 @1124 @1123 @1081 @1210 +@1217 := LexLeanPreservation.Rust.RepresentableL +@1218 := @10 @23 +@1220 := @226 @208 @225 +@1223 := @1217 (@226 @1218 @1220) +@1224 := (__e_hrep : @1223) -> @1123 +@1225 := fun (__e_hrep : @1223) => @1216 +@1226 := (s : @162) -> @1224 +@1227 := fun (s : @162) => @1225 +@1228 := (xs : @5) -> @1226 +@1229 := fun (xs : @5) => @1227 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R5/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R5/Compose/RustStd.lean deleted file mode 100644 index 28b9fee6f..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R5/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (n : Nat) (start : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat n), (_root_.LexLeanTarget.TargetSyntax.Value.nat start)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.denote n start) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat n), (_root_.LexLeanTarget.TargetSyntax.Value.nat start)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat n) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat start) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.root n start) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R5/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R5/Compose/RustStd.lex.tex new file mode 100644 index 000000000..403414d28 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R5/Compose/RustStd.lex.tex @@ -0,0 +1,468 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd.root : @924 := @925 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@64 := Prod.{0, 0} @3 +@65 := @64 @54 +@66 := 1 +@69 := Prod.mk.{0, 0} @3 @54 +@70 := @69 @66 +@71 := @70 @50 +@72 := 0 +@73 := @69 @72 +@74 := @73 @6 +@75 := @55 @65 +@76 := @56 @65 +@78 := @76 @74 @75 +@80 := @76 @71 @78 +@81 := Bool.true +@82 := LexLeanTarget.TargetSyntax.Function +@83 := LexLeanTarget.TargetSyntax.Program.functions +@84 := @83 @0 +@85 := LexLeanTarget.TargetSyntax.Ty +@86 := @55 @3 +@87 := @55 @85 +@88 := LexLeanTarget.TargetSyntax.Ty.unit +@89 := LexLeanTarget.TargetSyntax.Value.unit +@92 := LexLeanTarget.TargetSyntax.Expr.value @88 @89 +@97 := LexLeanTarget.TargetSyntax.Function.mk @86 @87 @88 @92 +@102 := List.getD.{0} @82 @84 @72 @97 +@106 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd.root @17 @72 +@107 := LexLeanPreservation.Rust.WTL +@115 := {p : @8} -> {c : @9} -> {A : @10} -> @107 @4 @15 @17 @57 @87 +@117 := LexLeanPreservation.Rust.wtl_nil @0 +@118 := @107 @0 +@124 := {c : @9} -> {A : @10} -> @118 @15 @17 @57 @87 +@125 := @117 @1 +@126 := @118 @1 +@130 := {A : @10} -> @126 @17 @57 @87 +@131 := @125 @2 +@132 := @126 @2 +@133 := @132 @57 +@134 := @133 @87 +@135 := List.{0} +@136 := @135 @54 +@137 := @135 @85 +@138 := #6 +@139 := @11 @138 +@140 := #5 +@141 := @139 @140 +@142 := #4 +@145 := @141 @142 @12 @4 +@146 := #7 +@151 := @107 @146 @138 @140 @4 @15 +@152 := #8 +@155 := @107 @152 @146 @138 +@157 := @58 @140 @12 +@158 := @155 @157 +@159 := @56 @85 +@161 := @159 @142 @4 +@171 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @145) -> (hs : @151) -> @158 @161 +@173 := LexLeanPreservation.Rust.wtl_cons @0 +@193 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> + (h : @27 @140 @142 @12 @4) -> (hs : @118 @138 @140 @4 @15) -> @118 @146 @138 @157 @161 +@194 := @173 @1 +@210 := {A : @10} -> + {v : @54} -> + {t : @85} -> + {vs : @136} -> + {ts : @137} -> (h : @36 @142 @12 @4) -> (hs : @126 @140 @4 @15) -> @126 @138 @157 @161 +@211 := @194 @2 +@213 := @43 @12 @4 +@215 := @132 @4 @15 +@223 := {v : @54} -> + {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @213) -> (hs : @215) -> @132 @157 @161 +@224 := @211 @50 +@225 := @5 @142 +@226 := @43 @225 +@227 := @226 @4 +@228 := @5 @138 +@229 := @58 @228 +@231 := @132 (@229 @12) +@237 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @227) -> (hs : @215) -> @231 @161 +@238 := @224 @7 +@239 := @5 @12 +@241 := @43 @239 @7 +@242 := @5 @140 +@243 := @58 @242 +@245 := @132 (@243 @12) +@246 := @159 @7 +@247 := @246 @4 +@252 := {vs : @136} -> {ts : @137} -> (h : @241) -> (hs : @215) -> @245 @247 +@253 := @238 @57 +@254 := @133 @15 +@255 := @58 @225 +@256 := @255 @57 +@261 := {ts : @137} -> (h : @49) -> (hs : @254) -> @132 @256 @247 +@262 := @253 @87 +@263 := @58 @239 +@264 := @263 @57 +@265 := @132 @264 +@266 := @246 @87 +@269 := (h : @53) -> (hs : @134) -> @265 @266 +@270 := @262 @51 +@271 := @61 @57 +@273 := @132 @271 @266 +@274 := (hs : @134) -> @273 +@275 := @270 @131 +@277 := @132 @60 @266 +@278 := @211 @6 +@280 := @43 @242 @4 +@281 := @5 @146 +@282 := @58 @281 +@290 := {t : @85} -> {vs : @136} -> {ts : @137} -> (h : @280) -> (hs : @215) -> @132 (@282 @12) @161 +@291 := @278 @7 +@297 := {vs : @136} -> {ts : @137} -> (h : @226 @7) -> (hs : @215) -> @231 @247 +@298 := @291 @60 +@299 := @265 @15 +@300 := @243 @256 +@301 := @132 @300 +@305 := {ts : @137} -> (h : @241) -> (hs : @299) -> @301 @247 +@306 := @298 @266 +@307 := @255 @264 +@308 := @132 @307 +@309 := @246 @266 +@312 := (h : @49) -> (hs : @273) -> @308 @309 +@313 := @306 @47 +@314 := @263 @271 +@315 := @132 @314 +@317 := (hs : @277) -> @315 @309 +@318 := @313 @275 +@319 := @132 @62 +@320 := @319 @309 +@321 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.__fits_0 +@326 := @324 @4 @15 +@329 := Coverage.Colls.iterations @4 @15 +@330 := Bool +@331 := @64 @330 +@332 := LexLeanTarget.TargetSyntax.Value.bool +@334 := LexLeanPreservation.encPair @3 +@337 := @334 @330 @5 @332 +@341 := @334 @331 @5 @337 @329 +@344 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.root @4 @15 +@345 := Ne.{1} +@346 := LexLeanPreservation.Obs +@347 := @345 @346 +@348 := LexLeanPreservation.Rel +@351 := @347 (@348 @15 @17) +@352 := LexLeanPreservation.Obs.stuck +@355 := (f : @330) -> (v : @54) -> @351 @352 +@357 := LexLeanPreservation.Rust.rel_ne_stuck @326 +@364 := (v : @54) -> @347 (@348 (@324 @12 @4) @17) @352 +@365 := @357 @341 +@369 := @347 (@348 @326 @341) @352 +@370 := @135 @65 +@371 := LexLeanPreservation.Rust.FunSem +@372 := #9 +@378 := (n : @3) -> @371 @372 @152 @146 @17 @138 +@379 := Eq.{1} +@380 := Option.{0} +@381 := @380 @82 +@382 := @379 @381 +@389 := LexLeanRuntime.index (@135 @82) @82 (LexLeanRuntime.instIndexableList @82) +@393 := @382 (@389 (@83 @372) @138) +@394 := Option.some.{0} +@395 := @394 @82 +@396 := @395 @140 +@397 := @393 @396 +@398 := #10 +@402 := @107 @398 @372 @152 @140 +@403 := LexLeanTarget.TargetSyntax.Function.types +@404 := @403 @138 +@405 := @402 @404 +@406 := @380 @370 +@407 := @379 @406 +@408 := LexLeanTarget.TargetSemantics.bindAll +@409 := LexLeanTarget.TargetSyntax.Function.parameters +@414 := @407 (@408 (@409 @146) @138 @75) +@415 := @394 @370 +@416 := @415 @140 +@417 := @414 @416 +@418 := @380 @330 +@419 := @379 @418 +@420 := LexLeanPreservation.Rust.fnFallible +@421 := #11 +@424 := @419 (@420 @421 @372) +@425 := @394 @330 +@426 := @425 @140 +@427 := @424 @426 +@428 := LexLeanPreservation.RunConv +@429 := #13 +@433 := @428 @429 @398 @152 @140 +@435 := @347 @138 @352 +@436 := Exists.{1} +@437 := LexLeanPreservation.Rust.ROut +@438 := @436 @437 +@439 := And +@440 := LexLeanPreservation.Rust.RealizesFn +@444 := @439 (@440 @372 @152 @17) +@445 := LexLeanPreservation.Rust.RCI +@447 := @445 #15 +@448 := LexLeanPreservation.Rust.fnIdent +@449 := @448 @429 +@456 := (hne : @435) -> @438 (fun (ro : @437) => @444 (@447 @449 @421 @17)) +@471 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @370} -> + {F : @330} -> + {o : @346} -> + (hB : @378) -> + (hfn : @397) -> (hwt : @405) -> (hbind : @417) -> (hF : @427) -> (hA : @433) -> @456 +@473 := LexLeanPreservation.Rust.compose @0 +@474 := @371 @0 +@479 := (n : @3) -> @474 @152 @146 @17 @138 +@480 := @389 @84 +@483 := @382 (@480 @138) @396 +@487 := @118 @372 @152 @140 @404 +@488 := @428 @0 +@491 := @488 @398 @152 @140 +@505 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @370} -> + {F : @330} -> + {o : @346} -> + (hB : @479) -> + (hfn : @483) -> (hwt : @487) -> (hbind : @417) -> (hF : @427) -> (hA : @491) -> @456 +@506 := @473 @1 +@507 := @474 @1 +@511 := (n : @3) -> @507 @146 @17 @138 +@514 := @126 @152 @140 @404 +@515 := @420 @1 +@518 := @419 (@515 @372) @426 +@519 := @445 @1 +@529 := (hbind : @417) -> + (hF : @518) -> (hA : @491) -> (hne : @435) -> @438 (fun (ro : @437) => @444 (@519 @449 @421 @17)) +@539 := {A : @10} -> + {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @370} -> {F : @330} -> {o : @346} -> (hB : @511) -> (hfn : @483) -> (hwt : @514) -> @529 +@540 := @506 @2 +@542 := @507 @2 @17 +@544 := (n : @3) -> @542 @138 +@545 := @132 @140 +@546 := @545 @404 +@555 := {f : @3} -> + {fn : @82} -> + {args : @136} -> + {env : @370} -> {F : @330} -> {o : @346} -> (hB : @544) -> (hfn : @483) -> (hwt : @546) -> @529 +@556 := @540 @72 +@558 := (n : @3) -> @542 @72 +@559 := @480 @72 +@560 := @382 @559 +@561 := @560 @396 +@562 := @515 @72 +@563 := @419 @562 +@564 := @563 @426 +@565 := @488 @72 +@567 := @565 @152 @140 +@569 := @519 (@448 @72) +@577 := (hF : @564) -> (hA : @567) -> (hne : @435) -> @438 (fun (ro : @437) => @444 (@569 @421 @17)) +@586 := {fn : @82} -> + {args : @136} -> + {env : @370} -> + {F : @330} -> {o : @346} -> (hB : @558) -> (hfn : @561) -> (hwt : @546) -> (hbind : @417) -> @577 +@587 := @556 @102 +@589 := @560 (@395 @102) +@590 := @403 @102 +@591 := @545 @590 +@593 := @408 (@409 @102) +@605 := {args : @136} -> + {env : @370} -> + {F : @330} -> + {o : @346} -> + (hB : @558) -> (hfn : @589) -> (hwt : @591) -> (hbind : @407 (@593 @138 @75) @416) -> @577 +@606 := @587 @62 +@608 := @282 (@229 @57) +@610 := @132 @608 @590 +@612 := @58 (@5 @152) +@614 := @612 (@282 @57) +@618 := @407 (@593 @614 @75) @416 +@620 := @58 (@5 @398) +@622 := @58 (@5 @372) +@624 := @620 (@622 @57) +@626 := @565 @624 @140 +@628 := @58 (@5 @429) +@631 := @58 (@5 #12) +@648 := {env : @370} -> + {F : @330} -> + {o : @346} -> + (hB : @558) -> + (hfn : @589) -> + (hwt : @610) -> + (hbind : @618) -> + (hF : @564) -> + (hA : @626) -> (hne : @435) -> @438 (fun (ro : @437) => @444 (@569 (@628 (@631 @57)) @17)) +@649 := @606 @80 +@651 := @229 (@243 @57) +@653 := @132 @651 @590 +@664 := @407 (@593 @608 @75) (@415 (@76 (@70 @228) (@76 (@73 @281) @75))) +@666 := @622 (@612 @57) +@668 := @565 @666 @140 +@670 := @58 (@5 @421) +@686 := {F : @330} -> + {o : @346} -> + (hB : @558) -> + (hfn : @589) -> + (hwt : @653) -> + (hbind : @664) -> + (hF : @564) -> + (hA : @668) -> (hne : @435) -> @438 (fun (ro : @437) => @444 (@569 (@631 (@670 @57)) @17)) +@687 := @649 @81 +@688 := @301 @590 +@699 := @407 (@593 @651 @75) (@415 (@76 (@70 @242) (@76 (@73 @228) @75))) +@701 := @563 (@425 @81) +@703 := @565 @614 @140 +@704 := @440 @81 +@722 := {o : @346} -> + (hB : @558) -> + (hfn : @589) -> + (hwt : @688) -> + (hbind : @699) -> + (hF : @701) -> + (hA : @703) -> + (hne : @435) -> @438 (fun (ro : @437) => @439 (@704 @152 @17) (@569 (@670 (@620 @57)) @17)) +@723 := @687 @323 +@724 := @308 @590 +@735 := @407 (@593 @300 @75) (@415 (@76 (@70 @225) (@76 (@73 @242) @75))) +@736 := @565 @608 +@738 := @321 @146 @138 +@739 := @736 @738 +@741 := @321 @152 @146 +@760 := (hB : @558) -> + (hfn : @589) -> + (hwt : @724) -> + (hbind : @735) -> + (hF : @701) -> + (hA : @739) -> + (hne : @347 @741 @352) -> + @438 (fun (ro : @437) => @439 (@704 (@321 @398 @372) @17) (@569 @624 @17)) +@761 := @723 @106 +@762 := @315 @590 +@773 := @407 (@593 @307 @75) (@415 (@76 (@70 @239) (@76 (@73 @225) @75))) +@774 := @565 @651 +@776 := @321 @138 @140 +@795 := (hfn : @589) -> + (hwt : @762) -> + (hbind : @773) -> + (hF : @701) -> + (hA : @774 @776) -> + (hne : @347 @738 @352) -> + @438 (fun (ro : @437) => @439 (@704 (@321 @372 @152) @17) (@569 @666 @17)) +@796 := Eq.refl.{1} +@799 := @761 (@796 @381 @559) +@800 := @319 @590 +@811 := @407 (@593 @314 @75) (@415 (@76 (@70 @6) (@76 (@73 @239) @75))) +@812 := @565 @300 +@814 := @321 @140 @142 +@830 := (hwt : @800) -> + (hbind : @811) -> + (hF : @701) -> + (hA : @812 @814) -> + (hne : @347 @776 @352) -> @438 (fun (ro : @437) => @439 (@704 @741 @17) (@569 @614 @17)) +@831 := @799 @318 +@833 := @593 @62 @75 +@836 := @407 @833 (@415 @80) +@837 := @565 @307 +@839 := @321 @142 @12 +@854 := (hbind : @836) -> + (hF : @701) -> + (hA : @837 @839) -> + (hne : @347 @814 @352) -> @438 (fun (ro : @437) => @439 (@704 @738 @17) (@569 @608 @17)) +@857 := @831 (@796 @406 @833) +@858 := @565 @314 +@860 := @321 @12 @4 +@874 := (hF : @701) -> + (hA : @858 @860) -> + (hne : @347 @839 @352) -> @438 (fun (ro : @437) => @439 (@704 @776 @17) (@569 @651 @17)) +@877 := @857 (@796 @418 @562) +@891 := (hA : @565 @62 @323) -> + (hne : @347 @860 @352) -> @438 (fun (ro : @437) => @439 (@704 @814 @17) (@569 @300 @17)) +@892 := @877 @344 +@903 := (hne : @347 @323 @352) -> @438 (fun (ro : @437) => @439 (@704 @839 @17) (@569 @307 @17)) +@904 := @892 @365 +@910 := @439 (@704 @860 @17) (@569 @314 @17) +@912 := @438 (fun (ro : @437) => @910) +@914 := @438 (fun (__e_ro : @437) => @910) +@919 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@920 := (__e_hrep : @919) -> @914 +@921 := fun (__e_hrep : @919) => @904 +@922 := (start : @3) -> @920 +@923 := fun (start : @3) => @921 +@924 := (n : @3) -> @922 +@925 := fun (n : @3) => @923 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R6/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R6/Compose/RustStd.lean deleted file mode 100644 index c3794a184..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R6/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd - -/-- The rendering of the root's entry, invoked on the encoded arguments, -realizes the encoded source result when the arguments satisfy §17.12's -invariants, and refuses them with `none` otherwise. -/ -theorem root (g : (List (Prod Nat (List Nat)))) (start : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat))) g), (_root_.LexLeanTarget.TargetSyntax.Value.nat start)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 30) [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat))) g), (_root_.LexLeanTarget.TargetSyntax.Value.nat start)] __e_ro ∧ - (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.accepts g start → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.denote g start)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.accepts g start → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none) __e_ro) := - match _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd.root __e_n 30) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat (_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat))) g) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat start) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.entry g start) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) with - | ⟨__e_ro, __e_hr, __e_hc⟩ => ⟨__e_ro, __e_hc, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.entry_accepts g start __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.entry_refuses g start __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R6/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R6/Compose/RustStd.lex.tex new file mode 100644 index 000000000..31119eadb --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R6/Compose/RustStd.lex.tex @@ -0,0 +1,676 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd.root : @1387 := @1388 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd.flags +@3 := Nat +@4 := List.{0} +@5 := @4 @3 +@6 := Prod.{0, 0} +@7 := @6 @3 +@8 := @7 @5 +@9 := @4 @8 +@10 := #2 +@11 := LexLeanTarget.TargetSyntax.Value.nat +@12 := LexLeanPreservation.encList +@13 := @12 @3 +@14 := @13 @11 +@15 := LexLeanPreservation.encPair +@16 := @15 @3 +@17 := @16 @5 +@18 := @17 @11 +@19 := @18 @14 +@20 := @12 @8 +@21 := @20 @19 +@22 := @21 @10 +@23 := LexLeanTarget.TargetSyntax.Ty.nat +@24 := LexLeanTarget.TargetSyntax.Ty.list +@25 := @24 @23 +@26 := LexLeanTarget.TargetSyntax.Ty.pair +@27 := @26 @23 +@28 := @27 @25 +@29 := @24 @28 +@30 := #0 +@31 := LexLeanTarget.TargetSyntax.Program +@32 := LexLeanPreservation.Rust.RCrate +@33 := LexLeanPreservation.Rust.Flags +@34 := LexLeanPreservation.Rust.WT +@35 := #3 +@37 := @34 @35 @10 +@38 := #1 +@39 := @37 @38 +@40 := @11 @30 +@46 := {p : @31} -> {c : @32} -> {A : @33} -> (n : @3) -> @39 @40 @23 +@48 := LexLeanPreservation.Rust.wt_nat @0 +@49 := @34 @0 +@56 := {c : @32} -> {A : @33} -> (n : @3) -> @49 @10 @38 @40 @23 +@57 := @48 @1 +@58 := @49 @1 +@63 := {A : @33} -> (n : @3) -> @58 @38 @40 @23 +@64 := @57 @2 +@65 := @58 @2 +@66 := @65 @40 +@67 := @66 @23 +@68 := (n : @3) -> @67 +@70 := fun (__x : @3) => @64 @30 +@71 := Sort 1 +@72 := LexLeanTarget.TargetSyntax.Value +@73 := (a._@._internal._hyg.#0 : @30) -> @72 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := #6 +@76 := @34 @75 +@77 := #5 +@78 := @76 @77 +@79 := #4 +@80 := @78 @79 +@81 := @10 @30 +@84 := (x : @10) -> @80 @81 @38 +@85 := @4 @35 +@86 := #7 +@89 := @34 @86 @75 @77 +@92 := @12 @79 @35 @30 +@93 := @89 @92 +@94 := @24 @10 +@103 := {p : @31} -> + {c : @32} -> + {A : @33} -> {α : @71} -> {e : @73} -> {t : @74} -> (h : @84) -> (xs : @85) -> @93 @94 +@105 := LexLeanPreservation.Rust.wt_encList @0 +@107 := @49 @77 @79 +@121 := {c : @32} -> + {A : @33} -> + {α : @71} -> + {e : @73} -> {t : @74} -> (h : (x : @10) -> @107 @81 @38) -> (xs : @85) -> @49 @75 @77 @92 @94 +@122 := @105 @1 +@123 := @58 @79 +@135 := {A : @33} -> + {α : @71} -> + {e : @73} -> {t : @74} -> (h : (x : @10) -> @123 @81 @38) -> (xs : @85) -> @58 @77 @92 @94 +@136 := @122 @2 +@138 := @65 @81 @38 +@146 := {α : @71} -> {e : @73} -> {t : @74} -> (h : (x : @10) -> @138) -> (xs : @85) -> @65 @92 @94 +@147 := @136 @3 +@148 := (a._@._internal._hyg.#0 : @3) -> @72 +@157 := {e : @148} -> {t : @74} -> (h : (x : @3) -> @138) -> (xs : @5) -> @65 (@13 @35 @30) @94 +@158 := @147 @11 +@160 := (x : @3) -> @66 @38 +@162 := @65 (@14 @30) +@166 := {t : @74} -> (h : @160) -> (xs : @5) -> @162 @94 +@167 := @158 @23 +@168 := (x : @3) -> @67 +@169 := @162 @25 +@171 := (h : @168) -> (xs : @5) -> @169 +@174 := fun (__x : @5) => @167 @70 @30 +@175 := (a._@._internal._hyg.#0 : @38) -> @72 +@176 := #9 +@177 := @34 @176 +@178 := #8 +@180 := @177 @178 @86 +@181 := @79 @30 +@184 := (x : @77) -> @180 @181 @10 +@185 := #10 +@191 := (x : @77) -> @34 @185 @176 @178 @181 @10 +@193 := @6 @86 @75 +@194 := #11 +@197 := @34 @194 @185 @176 +@202 := @15 @178 @86 @75 @77 @30 +@203 := @197 @202 +@205 := @26 @79 @35 +@218 := {p : @31} -> + {c : @32} -> + {A : @33} -> + {α : @71} -> + {β : @71} -> + {ea : @175} -> + {eb : @175} -> {s : @74} -> {t : @74} -> (ha : @184) -> (hb : @191) -> (x : @193) -> @203 @205 +@220 := LexLeanPreservation.Rust.wt_encPair @0 +@245 := {c : @32} -> + {A : @33} -> + {α : @71} -> + {β : @71} -> + {ea : @175} -> + {eb : @175} -> + {s : @74} -> + {t : @74} -> + (ha : (x : @77) -> @49 @178 @86 @181 @10) -> + (hb : (x : @77) -> @49 @176 @178 @181 @10) -> (x : @193) -> @49 @185 @176 @202 @205 +@246 := @220 @1 +@267 := {A : @33} -> + {α : @71} -> + {β : @71} -> + {ea : @175} -> + {eb : @175} -> + {s : @74} -> + {t : @74} -> + (ha : (x : @77) -> @58 @86 @181 @10) -> + (hb : (x : @77) -> @58 @178 @181 @10) -> (x : @193) -> @58 @176 @202 @205 +@268 := @246 @2 +@270 := @65 @181 @10 +@271 := (x : @77) -> @270 +@282 := {α : @71} -> + {β : @71} -> + {ea : @175} -> + {eb : @175} -> {s : @74} -> {t : @74} -> (ha : @271) -> (hb : @271) -> (x : @193) -> @65 @202 @205 +@283 := @268 @3 +@284 := (x : @3) -> @270 +@299 := {β : @71} -> + {ea : @148} -> + {eb : @175} -> + {s : @74} -> + {t : @74} -> (ha : @284) -> (hb : @271) -> (x : @7 @75) -> @65 (@16 @86 @75 @77 @30) @205 +@300 := @283 @5 +@301 := (a._@._internal._hyg.#0 : @5) -> @72 +@302 := (x : @5) -> @270 +@314 := {ea : @148} -> + {eb : @301} -> + {s : @74} -> {t : @74} -> (ha : @284) -> (hb : @302) -> (x : @8) -> @65 (@17 @75 @77 @30) @205 +@315 := @300 @11 +@317 := (x : @3) -> @66 @10 +@327 := {eb : @301} -> + {s : @74} -> {t : @74} -> (ha : @317) -> (hb : @302) -> (x : @8) -> @65 (@18 @77 @30) @205 +@328 := @315 @14 +@330 := (x : @5) -> @162 @10 +@332 := @65 (@19 @30) +@338 := {s : @74} -> {t : @74} -> (ha : @317) -> (hb : @330) -> (x : @8) -> @332 @205 +@339 := @328 @23 +@345 := {t : @74} -> (ha : @168) -> (hb : @330) -> (x : @8) -> @332 (@27 @35) +@346 := @339 @25 +@347 := (x : @5) -> @169 +@349 := (x : @8) -> @332 @28 +@351 := (ha : @168) -> (hb : @347) -> @349 +@355 := fun (__x : @8) => @346 @70 @174 @30 +@356 := @136 @8 +@366 := {e : (a._@._internal._hyg.#0 : @8) -> @72} -> + {t : @74} -> (h : (x : @8) -> @138) -> (xs : @9) -> @65 (@20 @35 @30) @94 +@367 := @356 @19 +@369 := (x : @8) -> @332 @38 +@371 := @65 (@21 @30) +@375 := {t : @74} -> (h : @369) -> (xs : @9) -> @371 @94 +@376 := @367 @28 +@379 := (h : @349) -> (xs : @9) -> @371 @29 +@381 := @376 @355 @10 +@383 := @65 @22 @29 +@384 := @11 @38 +@385 := @64 @38 +@387 := @65 @384 @23 +@388 := List.nil.{0} +@389 := List.cons.{0} +@390 := @388 @72 +@391 := @389 @72 +@393 := @391 @384 @390 +@395 := @391 @22 @393 +@396 := @7 @72 +@397 := 1 +@400 := Prod.mk.{0, 0} @3 @72 +@401 := @400 @397 +@402 := @401 @384 +@404 := @400 0 +@405 := @404 @22 +@406 := @388 @396 +@407 := @389 @396 +@409 := @407 @405 @406 +@411 := @407 @402 @409 +@412 := Bool.true +@413 := LexLeanTarget.TargetSyntax.Function +@414 := LexLeanTarget.TargetSyntax.Program.functions +@415 := @414 @0 +@416 := 30 +@417 := @388 @3 +@418 := @388 @74 +@419 := LexLeanTarget.TargetSyntax.Ty.unit +@420 := LexLeanTarget.TargetSyntax.Value.unit +@423 := LexLeanTarget.TargetSyntax.Expr.value @419 @420 +@428 := LexLeanTarget.TargetSyntax.Function.mk @417 @418 @419 @423 +@433 := List.getD.{0} @413 @415 @416 @428 +@437 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd.root @30 @416 +@438 := LexLeanPreservation.Rust.WTL +@446 := {p : @31} -> {c : @32} -> {A : @33} -> @438 @10 @38 @30 @390 @418 +@448 := LexLeanPreservation.Rust.wtl_nil @0 +@449 := @438 @0 +@455 := {c : @32} -> {A : @33} -> @449 @38 @30 @390 @418 +@456 := @448 @1 +@457 := @449 @1 +@461 := {A : @33} -> @457 @30 @390 @418 +@462 := @456 @2 +@463 := @457 @2 +@464 := @463 @390 +@465 := @464 @418 +@466 := @4 @72 +@467 := @4 @74 +@469 := @80 @35 @10 +@474 := @438 @86 @75 @77 @10 @38 +@477 := @438 @178 @86 @75 +@479 := @391 @77 @35 +@480 := @477 @479 +@481 := @389 @74 +@483 := @481 @79 @10 +@493 := {p : @31} -> + {c : @32} -> + {A : @33} -> + {v : @72} -> {t : @74} -> {vs : @466} -> {ts : @467} -> (h : @469) -> (hs : @474) -> @480 @483 +@495 := LexLeanPreservation.Rust.wtl_cons @0 +@513 := {c : @32} -> + {A : @33} -> + {v : @72} -> + {t : @74} -> + {vs : @466} -> + {ts : @467} -> (h : @107 @35 @10) -> (hs : @449 @75 @77 @10 @38) -> @449 @86 @75 @479 @483 +@514 := @495 @1 +@529 := {A : @33} -> + {v : @72} -> + {t : @74} -> + {vs : @466} -> {ts : @467} -> (h : @123 @35 @10) -> (hs : @457 @77 @10 @38) -> @457 @75 @479 @483 +@530 := @514 @2 +@532 := @65 @35 @10 +@534 := @463 @10 @38 +@542 := {v : @72} -> + {t : @74} -> {vs : @466} -> {ts : @467} -> (h : @532) -> (hs : @534) -> @463 @479 @483 +@543 := @530 @384 +@544 := @11 @79 +@546 := @65 @544 @10 +@547 := @11 @75 +@548 := @391 @547 +@556 := {t : @74} -> {vs : @466} -> {ts : @467} -> (h : @546) -> (hs : @534) -> @463 (@548 @35) @483 +@557 := @543 @23 +@558 := @11 @35 +@560 := @65 @558 @23 +@561 := @11 @77 +@562 := @391 @561 +@564 := @463 (@562 @35) +@565 := @481 @23 +@566 := @565 @10 +@571 := {vs : @466} -> {ts : @467} -> (h : @560) -> (hs : @534) -> @564 @566 +@572 := @557 @390 +@573 := @11 @10 +@575 := @65 @573 @23 +@576 := @464 @38 +@578 := @391 @544 @390 +@583 := {ts : @467} -> (h : @575) -> (hs : @576) -> @463 @578 @566 +@584 := @572 @418 +@586 := @391 @558 @390 +@587 := @463 @586 +@588 := @565 @418 +@591 := (h : @387) -> (hs : @465) -> @587 @588 +@592 := @584 @385 +@594 := @391 @573 @390 +@596 := @463 @594 @588 +@597 := (hs : @465) -> @596 +@598 := @592 @462 +@600 := @463 @393 @588 +@601 := @530 @22 +@602 := @21 @77 +@604 := @65 @602 @10 +@605 := @21 @86 +@606 := @391 @605 +@614 := {t : @74} -> {vs : @466} -> {ts : @467} -> (h : @604) -> (hs : @534) -> @463 (@606 @35) @483 +@615 := @601 @29 +@616 := @21 @79 +@618 := @65 @616 @29 +@619 := @21 @75 +@620 := @391 @619 +@622 := @463 (@620 @35) +@623 := @481 @29 +@624 := @623 @10 +@629 := {vs : @466} -> {ts : @467} -> (h : @618) -> (hs : @534) -> @622 @624 +@630 := @615 @393 +@631 := @21 @35 +@633 := @65 @631 @29 +@634 := @587 @38 +@636 := @391 @602 @578 +@637 := @463 @636 +@641 := {ts : @467} -> (h : @633) -> (hs : @634) -> @637 @624 +@642 := @630 @588 +@644 := @391 @616 @586 +@645 := @463 @644 +@646 := @623 @588 +@649 := (h : @383) -> (hs : @596) -> @645 @646 +@650 := @642 @381 +@652 := @391 @631 @594 +@653 := @463 @652 +@655 := (hs : @600) -> @653 @646 +@656 := @650 @598 +@657 := @463 @395 +@658 := @657 @646 +@659 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.denoteEntry +@661 := @659 @10 @38 +@662 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.entryFits +@664 := @662 @10 @38 +@667 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.entryValue @10 @38 +@670 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.entry @10 @38 +@671 := Bool +@672 := Ne.{1} +@673 := LexLeanPreservation.Obs +@674 := @672 @673 +@675 := LexLeanPreservation.Rel +@678 := @674 (@675 @38 @30) +@679 := LexLeanPreservation.Obs.stuck +@682 := (f : @671) -> (v : @72) -> @678 @679 +@684 := LexLeanPreservation.Rust.rel_ne_stuck @664 +@691 := (v : @72) -> @674 (@675 (@662 @35 @10) @30) @679 +@692 := @684 @667 +@696 := @674 (@675 @664 @667) @679 +@697 := @4 @396 +@698 := LexLeanPreservation.Rust.FunSem +@704 := (n : @3) -> @698 @176 @178 @86 @30 @75 +@705 := Eq.{1} +@706 := Option.{0} +@707 := @706 @413 +@708 := @705 @707 +@715 := LexLeanRuntime.index (@4 @413) @413 (LexLeanRuntime.instIndexableList @413) +@719 := @708 (@715 (@414 @176) @75) +@720 := Option.some.{0} +@721 := @720 @413 +@722 := @721 @77 +@723 := @719 @722 +@727 := @438 @185 @176 @178 @77 +@728 := LexLeanTarget.TargetSyntax.Function.types +@729 := @728 @75 +@730 := @727 @729 +@731 := @706 @697 +@732 := @705 @731 +@733 := LexLeanTarget.TargetSemantics.bindAll +@734 := LexLeanTarget.TargetSyntax.Function.parameters +@739 := @732 (@733 (@734 @86) @75 @406) +@740 := @720 @697 +@741 := @740 @77 +@742 := @739 @741 +@743 := @706 @671 +@744 := @705 @743 +@745 := LexLeanPreservation.Rust.fnFallible +@748 := @744 (@745 @194 @176) +@749 := @720 @671 +@750 := @749 @77 +@751 := @748 @750 +@752 := LexLeanPreservation.RunConv +@753 := #13 +@757 := @752 @753 @185 @178 @77 +@759 := @674 @75 @679 +@760 := Exists.{1} +@761 := LexLeanPreservation.Rust.ROut +@762 := @760 @761 +@763 := And +@764 := LexLeanPreservation.Rust.RealizesFn +@768 := @763 (@764 @176 @178 @30) +@769 := LexLeanPreservation.Rust.RCI +@771 := @769 #15 +@772 := LexLeanPreservation.Rust.fnIdent +@773 := @772 @753 +@780 := (hne : @759) -> @762 (fun (ro : @761) => @768 (@771 @773 @194 @30)) +@795 := {p : @31} -> + {c : @32} -> + {A : @33} -> + {f : @3} -> + {fn : @413} -> + {args : @466} -> + {env : @697} -> + {F : @671} -> + {o : @673} -> + (hB : @704) -> + (hfn : @723) -> (hwt : @730) -> (hbind : @742) -> (hF : @751) -> (hA : @757) -> @780 +@797 := LexLeanPreservation.Rust.compose @0 +@798 := @698 @0 +@803 := (n : @3) -> @798 @178 @86 @30 @75 +@804 := @715 @415 +@807 := @708 (@804 @75) @722 +@811 := @449 @176 @178 @77 @729 +@812 := @752 @0 +@815 := @812 @185 @178 @77 +@829 := {c : @32} -> + {A : @33} -> + {f : @3} -> + {fn : @413} -> + {args : @466} -> + {env : @697} -> + {F : @671} -> + {o : @673} -> + (hB : @803) -> + (hfn : @807) -> (hwt : @811) -> (hbind : @742) -> (hF : @751) -> (hA : @815) -> @780 +@830 := @797 @1 +@831 := @798 @1 +@835 := (n : @3) -> @831 @86 @30 @75 +@838 := @457 @178 @77 @729 +@839 := @745 @1 +@842 := @744 (@839 @176) @750 +@843 := @769 @1 +@853 := (hbind : @742) -> + (hF : @842) -> (hA : @815) -> (hne : @759) -> @762 (fun (ro : @761) => @768 (@843 @773 @194 @30)) +@863 := {A : @33} -> + {f : @3} -> + {fn : @413} -> + {args : @466} -> + {env : @697} -> {F : @671} -> {o : @673} -> (hB : @835) -> (hfn : @807) -> (hwt : @838) -> @853 +@864 := @830 @2 +@866 := @831 @2 @30 +@868 := (n : @3) -> @866 @75 +@869 := @463 @77 +@870 := @869 @729 +@879 := {f : @3} -> + {fn : @413} -> + {args : @466} -> + {env : @697} -> {F : @671} -> {o : @673} -> (hB : @868) -> (hfn : @807) -> (hwt : @870) -> @853 +@880 := @864 @416 +@882 := (n : @3) -> @866 @416 +@883 := @804 @416 +@884 := @708 @883 +@885 := @884 @722 +@886 := @839 @416 +@887 := @744 @886 +@888 := @887 @750 +@889 := @812 @416 +@891 := @889 @178 @77 +@893 := @843 (@772 @416) +@901 := (hF : @888) -> (hA : @891) -> (hne : @759) -> @762 (fun (ro : @761) => @768 (@893 @194 @30)) +@910 := {fn : @413} -> + {args : @466} -> + {env : @697} -> + {F : @671} -> {o : @673} -> (hB : @882) -> (hfn : @885) -> (hwt : @870) -> (hbind : @742) -> @901 +@911 := @880 @433 +@913 := @884 (@721 @433) +@914 := @728 @433 +@915 := @869 @914 +@917 := @733 (@734 @433) +@929 := {args : @466} -> + {env : @697} -> + {F : @671} -> + {o : @673} -> + (hB : @882) -> (hfn : @913) -> (hwt : @915) -> (hbind : @732 (@917 @75 @406) @741) -> @901 +@930 := @911 @395 +@932 := @606 (@548 @390) +@934 := @463 @932 @914 +@940 := @391 (@21 @178) (@391 (@11 @86) @390) +@944 := @732 (@917 @940 @406) @741 +@950 := @391 (@21 @185) (@391 (@11 @176) @390) +@952 := @889 @950 @77 +@954 := @391 (@21 @753) +@955 := #12 +@974 := {env : @697} -> + {F : @671} -> + {o : @673} -> + (hB : @882) -> + (hfn : @913) -> + (hwt : @934) -> + (hbind : @944) -> + (hF : @888) -> + (hA : @952) -> + (hne : @759) -> @762 (fun (ro : @761) => @768 (@893 (@954 (@391 (@11 @955) @390)) @30)) +@975 := @930 @411 +@977 := @620 (@562 @390) +@979 := @463 @977 @914 +@990 := @732 (@917 @932 @406) (@740 (@407 (@401 @547) (@407 (@404 @605) @406))) +@996 := @391 (@21 @176) (@391 (@11 @178) @390) +@1018 := {F : @671} -> + {o : @673} -> + (hB : @882) -> + (hfn : @913) -> + (hwt : @979) -> + (hbind : @990) -> + (hF : @888) -> + (hA : @889 @996 @77) -> + (hne : @759) -> @762 (fun (ro : @761) => @768 (@893 (@391 (@21 @955) (@391 (@11 @194) @390)) @30)) +@1019 := @975 @412 +@1020 := @637 @914 +@1031 := @732 (@917 @977 @406) (@740 (@407 (@401 @561) (@407 (@404 @619) @406))) +@1033 := @887 (@749 @412) +@1035 := @889 @940 @77 +@1036 := @764 @412 +@1058 := {o : @673} -> + (hB : @882) -> + (hfn : @913) -> + (hwt : @1020) -> + (hbind : @1031) -> + (hF : @1033) -> + (hA : @1035) -> + (hne : @759) -> + @762 + (fun (ro : @761) => @763 (@1036 @178 @30) (@893 (@391 (@21 @194) (@391 (@11 @185) @390)) @30)) +@1059 := @1019 @661 +@1060 := @645 @914 +@1071 := @732 (@917 @636 @406) (@740 (@407 (@401 @544) (@407 (@404 @602) @406))) +@1072 := @889 @932 +@1074 := @659 @86 @75 +@1075 := @1072 @1074 +@1077 := @659 @178 @86 +@1096 := (hB : @882) -> + (hfn : @913) -> + (hwt : @1060) -> + (hbind : @1071) -> + (hF : @1033) -> + (hA : @1075) -> + (hne : @674 @1077 @679) -> + @762 (fun (ro : @761) => @763 (@1036 (@659 @185 @176) @30) (@893 @950 @30)) +@1097 := @1059 @437 +@1098 := @653 @914 +@1109 := @732 (@917 @644 @406) (@740 (@407 (@401 @558) (@407 (@404 @616) @406))) +@1110 := @889 @977 +@1112 := @659 @75 @77 +@1131 := (hfn : @913) -> + (hwt : @1098) -> + (hbind : @1109) -> + (hF : @1033) -> + (hA : @1110 @1112) -> + (hne : @674 @1074 @679) -> + @762 (fun (ro : @761) => @763 (@1036 (@659 @176 @178) @30) (@893 @996 @30)) +@1132 := Eq.refl.{1} +@1135 := @1097 (@1132 @707 @883) +@1136 := @657 @914 +@1147 := @732 (@917 @652 @406) (@740 (@407 (@401 @573) (@407 (@404 @631) @406))) +@1148 := @889 @636 +@1150 := @659 @77 @79 +@1166 := (hwt : @1136) -> + (hbind : @1147) -> + (hF : @1033) -> + (hA : @1148 @1150) -> + (hne : @674 @1112 @679) -> @762 (fun (ro : @761) => @763 (@1036 @1077 @30) (@893 @940 @30)) +@1167 := @1135 @656 +@1169 := @917 @395 @406 +@1172 := @732 @1169 (@740 @411) +@1173 := @889 @644 +@1175 := @659 @79 @35 +@1190 := (hbind : @1172) -> + (hF : @1033) -> + (hA : @1173 @1175) -> + (hne : @674 @1150 @679) -> @762 (fun (ro : @761) => @763 (@1036 @1074 @30) (@893 @932 @30)) +@1193 := @1167 (@1132 @731 @1169) +@1194 := @889 @652 +@1196 := @659 @35 @10 +@1210 := (hF : @1033) -> + (hA : @1194 @1196) -> + (hne : @674 @1175 @679) -> @762 (fun (ro : @761) => @763 (@1036 @1112 @30) (@893 @977 @30)) +@1213 := @1193 (@1132 @743 @886) +@1215 := @889 @395 @661 +@1217 := @674 @1196 @679 +@1218 := @1036 @1150 +@1220 := @763 (@1218 @30) +@1221 := @893 @636 +@1222 := @1221 @30 +@1227 := (hA : @1215) -> (hne : @1217) -> @762 (fun (ro : @761) => @1220 @1222) +@1228 := @1213 @670 +@1230 := @674 @661 @679 +@1231 := @1036 @1175 +@1233 := @763 (@1231 @30) +@1234 := @893 @644 +@1239 := (hne : @1230) -> @762 (fun (ro : @761) => @1233 (@1234 @30)) +@1240 := @1228 @692 +@1243 := @763 (@1036 @1196 @30) +@1245 := @893 @652 @30 +@1246 := @1243 @1245 +@1248 := @762 (fun (ro : @761) => @1246) +@1249 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.accepts +@1251 := @1249 @10 @38 +@1252 := LexLeanPreservation.someObs +@1253 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.denote +@1256 := @1252 (@1253 @10 @38) +@1259 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none +@1260 := Not +@1261 := @1260 @1251 +@1263 := @1249 @35 @10 +@1266 := @1252 (@1253 @35 @10) +@1267 := @1260 @1263 +@1273 := @1263 -> @1036 (@1252 (@1253 @79 @35)) @38 +@1274 := @1036 @1259 +@1275 := @1274 @38 +@1276 := @1267 -> @1275 +@1278 := @763 @1273 @1276 +@1282 := @762 (fun (__e_ro : @761) => @763 @1245 @1278) +@1283 := fun (__e_ro : @761) => @1246 +@1284 := @1231 @38 +@1285 := @1234 @38 +@1286 := And.left +@1287 := And.right +@1290 := @1286 @1284 @1285 @30 +@1293 := @1287 @1284 @1285 @30 +@1294 := @1036 @30 +@1296 := fun (__e_o : @673) => @1294 @10 +@1297 := Eq.subst.{1} +@1299 := @1249 @79 @35 +@1300 := @1260 @1299 +@1304 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.entry_accepts @77 @79 @30 +@1307 := @1252 (@1253 @77 @79) +@1312 := @1286 (@1218 @10) (@1221 @10) @38 +@1314 := fun (__e_o : @673) => @1294 @35 +@1317 := @1297 @673 @1314 @1150 +@1321 := fun (__e_h : @1299) => @1317 @1307 @1304 @1312 +@1325 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.entry_refuses @77 @79 @30 +@1329 := fun (__e_h : @1300) => @1317 @1259 @1325 @1312 +@1330 := And.intro +@1333 := @1299 -> @1036 @1307 @10 +@1335 := @1300 -> @1274 @10 +@1337 := @763 @1333 @1335 +@1341 := @1330 @1333 @1335 @1321 @1329 +@1345 := @1330 @1285 @1337 @1293 @1341 +@1346 := Exists.intro.{1} +@1347 := @763 @1222 +@1349 := @1249 @77 @79 +@1361 := fun (__e_ro : @761) => + @1347 (@763 (@1349 -> @1036 (@1252 (@1253 @75 @77)) @38) (@1260 @1349 -> @1275)) +@1365 := @1346 @761 @1361 @38 @1345 +@1367 := @763 @1284 @1285 +@1369 := fun (__e_ro : @761) => fun (__e_hand : @1246) => @1365 +@1375 := Exists.elim.{1} @761 @1283 @1282 @1240 @1369 +@1376 := LexLeanPreservation.Rust.RepresentableL +@1377 := @21 @38 +@1379 := @391 @40 @390 +@1382 := @1376 (@391 @1377 @1379) +@1383 := (__e_hrep : @1382) -> @1282 +@1384 := fun (__e_hrep : @1382) => @1375 +@1385 := (start : @3) -> @1383 +@1386 := fun (start : @3) => @1384 +@1387 := (g : @9) -> @1385 +@1388 := fun (g : @9) => @1386 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R7/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R7/Compose/RustStd.lean deleted file mode 100644 index 203b6c565..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R7/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd - -/-- The rendering of the root's entry, invoked on the encoded arguments, -realizes the encoded source result when the arguments satisfy §17.12's -invariants, and refuses them with `none` otherwise. -/ -theorem root (g : (List (Prod String (List String)))) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.string))) g)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 15) [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.string (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.string))) g)] __e_ro ∧ - (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.accepts g → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.denote g)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.accepts g → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none) __e_ro) := - match _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd.root __e_n 15) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_string (_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_string))) g) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.entry g) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) with - | ⟨__e_ro, __e_hr, __e_hc⟩ => ⟨__e_ro, __e_hc, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.entry_accepts g __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.entry_refuses g __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R7/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R7/Compose/RustStd.lex.tex new file mode 100644 index 000000000..2814d65c5 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R7/Compose/RustStd.lex.tex @@ -0,0 +1,626 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd.root : @1256 := @1257 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd.flags +@3 := String +@4 := List.{0} +@5 := @4 @3 +@6 := Prod.{0, 0} +@7 := @6 @3 +@8 := @7 @5 +@9 := @4 @8 +@10 := #1 +@11 := LexLeanTarget.TargetSyntax.Value.string +@12 := LexLeanPreservation.encList +@13 := @12 @3 +@14 := @13 @11 +@15 := LexLeanPreservation.encPair +@16 := @15 @3 +@17 := @16 @5 +@18 := @17 @11 +@19 := @18 @14 +@20 := @12 @8 +@21 := @20 @19 +@22 := @21 @10 +@23 := LexLeanTarget.TargetSyntax.Ty.string +@24 := LexLeanTarget.TargetSyntax.Ty.list +@25 := @24 @23 +@26 := LexLeanTarget.TargetSyntax.Ty.pair +@27 := @26 @23 +@28 := @27 @25 +@29 := @24 @28 +@30 := #0 +@31 := LexLeanTarget.TargetSyntax.Program +@32 := LexLeanPreservation.Rust.RCrate +@33 := LexLeanPreservation.Rust.Flags +@34 := LexLeanPreservation.Rust.WT +@35 := #3 +@36 := @34 @35 +@37 := #2 +@39 := @36 @37 @10 +@40 := @11 @30 +@46 := {p : @31} -> {c : @32} -> {A : @33} -> (s : @3) -> @39 @40 @23 +@48 := LexLeanPreservation.Rust.wt_string @0 +@49 := @34 @0 +@56 := {c : @32} -> {A : @33} -> (s : @3) -> @49 @37 @10 @40 @23 +@57 := @48 @1 +@58 := @49 @1 +@63 := {A : @33} -> (s : @3) -> @58 @10 @40 @23 +@64 := @57 @2 +@65 := @58 @2 +@66 := @65 @40 +@67 := @66 @23 +@68 := (s : @3) -> @67 +@70 := fun (__x : @3) => @64 @30 +@71 := Sort 1 +@72 := LexLeanTarget.TargetSyntax.Value +@73 := (a._@._internal._hyg.#0 : @30) -> @72 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := #6 +@76 := @34 @75 +@77 := #5 +@78 := @76 @77 +@79 := #4 +@80 := @78 @79 +@81 := @37 @30 +@84 := (x : @37) -> @80 @81 @10 +@85 := @4 @35 +@86 := #7 +@89 := @34 @86 @75 @77 +@92 := @12 @79 @35 @30 +@93 := @89 @92 +@94 := @24 @37 +@103 := {p : @31} -> + {c : @32} -> + {A : @33} -> {α : @71} -> {e : @73} -> {t : @74} -> (h : @84) -> (xs : @85) -> @93 @94 +@105 := LexLeanPreservation.Rust.wt_encList @0 +@107 := @49 @77 @79 +@121 := {c : @32} -> + {A : @33} -> + {α : @71} -> + {e : @73} -> {t : @74} -> (h : (x : @37) -> @107 @81 @10) -> (xs : @85) -> @49 @75 @77 @92 @94 +@122 := @105 @1 +@123 := @58 @79 +@135 := {A : @33} -> + {α : @71} -> + {e : @73} -> {t : @74} -> (h : (x : @37) -> @123 @81 @10) -> (xs : @85) -> @58 @77 @92 @94 +@136 := @122 @2 +@138 := @65 @81 @10 +@146 := {α : @71} -> {e : @73} -> {t : @74} -> (h : (x : @37) -> @138) -> (xs : @85) -> @65 @92 @94 +@147 := @136 @3 +@148 := (a._@._internal._hyg.#0 : @3) -> @72 +@157 := {e : @148} -> {t : @74} -> (h : (x : @3) -> @138) -> (xs : @5) -> @65 (@13 @35 @30) @94 +@158 := @147 @11 +@160 := (x : @3) -> @66 @10 +@162 := @65 (@14 @30) +@166 := {t : @74} -> (h : @160) -> (xs : @5) -> @162 @94 +@167 := @158 @23 +@168 := (x : @3) -> @67 +@169 := @162 @25 +@171 := (h : @168) -> (xs : @5) -> @169 +@174 := fun (__x : @5) => @167 @70 @30 +@175 := (a._@._internal._hyg.#0 : @10) -> @72 +@176 := #9 +@177 := @34 @176 +@178 := #8 +@180 := @177 @178 @86 +@181 := @79 @30 +@184 := (x : @77) -> @180 @181 @37 +@185 := #10 +@191 := (x : @77) -> @34 @185 @176 @178 @181 @37 +@193 := @6 @86 @75 +@194 := #11 +@197 := @34 @194 @185 @176 +@202 := @15 @178 @86 @75 @77 @30 +@203 := @197 @202 +@205 := @26 @79 @35 +@218 := {p : @31} -> + {c : @32} -> + {A : @33} -> + {α : @71} -> + {β : @71} -> + {ea : @175} -> + {eb : @175} -> {s : @74} -> {t : @74} -> (ha : @184) -> (hb : @191) -> (x : @193) -> @203 @205 +@220 := LexLeanPreservation.Rust.wt_encPair @0 +@245 := {c : @32} -> + {A : @33} -> + {α : @71} -> + {β : @71} -> + {ea : @175} -> + {eb : @175} -> + {s : @74} -> + {t : @74} -> + (ha : (x : @77) -> @49 @178 @86 @181 @37) -> + (hb : (x : @77) -> @49 @176 @178 @181 @37) -> (x : @193) -> @49 @185 @176 @202 @205 +@246 := @220 @1 +@267 := {A : @33} -> + {α : @71} -> + {β : @71} -> + {ea : @175} -> + {eb : @175} -> + {s : @74} -> + {t : @74} -> + (ha : (x : @77) -> @58 @86 @181 @37) -> + (hb : (x : @77) -> @58 @178 @181 @37) -> (x : @193) -> @58 @176 @202 @205 +@268 := @246 @2 +@270 := @65 @181 @37 +@271 := (x : @77) -> @270 +@282 := {α : @71} -> + {β : @71} -> + {ea : @175} -> + {eb : @175} -> {s : @74} -> {t : @74} -> (ha : @271) -> (hb : @271) -> (x : @193) -> @65 @202 @205 +@283 := @268 @3 +@284 := (x : @3) -> @270 +@299 := {β : @71} -> + {ea : @148} -> + {eb : @175} -> + {s : @74} -> + {t : @74} -> (ha : @284) -> (hb : @271) -> (x : @7 @75) -> @65 (@16 @86 @75 @77 @30) @205 +@300 := @283 @5 +@301 := (a._@._internal._hyg.#0 : @5) -> @72 +@302 := (x : @5) -> @270 +@314 := {ea : @148} -> + {eb : @301} -> + {s : @74} -> {t : @74} -> (ha : @284) -> (hb : @302) -> (x : @8) -> @65 (@17 @75 @77 @30) @205 +@315 := @300 @11 +@317 := (x : @3) -> @66 @37 +@327 := {eb : @301} -> + {s : @74} -> {t : @74} -> (ha : @317) -> (hb : @302) -> (x : @8) -> @65 (@18 @77 @30) @205 +@328 := @315 @14 +@330 := (x : @5) -> @162 @37 +@332 := @65 (@19 @30) +@338 := {s : @74} -> {t : @74} -> (ha : @317) -> (hb : @330) -> (x : @8) -> @332 @205 +@339 := @328 @23 +@345 := {t : @74} -> (ha : @168) -> (hb : @330) -> (x : @8) -> @332 (@27 @35) +@346 := @339 @25 +@347 := (x : @5) -> @169 +@349 := (x : @8) -> @332 @28 +@351 := (ha : @168) -> (hb : @347) -> @349 +@355 := fun (__x : @8) => @346 @70 @174 @30 +@356 := @136 @8 +@366 := {e : (a._@._internal._hyg.#0 : @8) -> @72} -> + {t : @74} -> (h : (x : @8) -> @138) -> (xs : @9) -> @65 (@20 @35 @30) @94 +@367 := @356 @19 +@369 := (x : @8) -> @332 @10 +@370 := @21 @30 +@371 := @65 @370 +@375 := {t : @74} -> (h : @369) -> (xs : @9) -> @371 @94 +@376 := @367 @28 +@379 := (h : @349) -> (xs : @9) -> @371 @29 +@381 := @376 @355 @10 +@383 := @65 @22 @29 +@384 := List.nil.{0} +@385 := List.cons.{0} +@386 := @384 @72 +@387 := @385 @72 +@389 := @387 @22 @386 +@390 := Nat +@392 := @6 @390 @72 +@393 := 0 +@397 := Prod.mk.{0, 0} @390 @72 @393 +@398 := @397 @22 +@399 := @384 @392 +@400 := @385 @392 +@402 := @400 @398 @399 +@403 := Bool.true +@404 := LexLeanTarget.TargetSyntax.Function +@405 := LexLeanTarget.TargetSyntax.Program.functions +@406 := @405 @0 +@407 := 15 +@408 := @384 @390 +@409 := @384 @74 +@410 := LexLeanTarget.TargetSyntax.Ty.unit +@411 := LexLeanTarget.TargetSyntax.Value.unit +@414 := LexLeanTarget.TargetSyntax.Expr.value @410 @411 +@419 := LexLeanTarget.TargetSyntax.Function.mk @408 @409 @410 @414 +@424 := List.getD.{0} @404 @406 @407 @419 +@428 := fun (__e_n : @390) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd.root @30 @407 +@429 := LexLeanPreservation.Rust.WTL +@437 := {p : @31} -> {c : @32} -> {A : @33} -> @429 @37 @10 @30 @386 @409 +@439 := LexLeanPreservation.Rust.wtl_nil @0 +@440 := @429 @0 +@446 := {c : @32} -> {A : @33} -> @440 @10 @30 @386 @409 +@447 := @439 @1 +@448 := @440 @1 +@452 := {A : @33} -> @448 @30 @386 @409 +@453 := @447 @2 +@454 := @448 @2 +@455 := @454 @386 +@456 := @455 @409 +@457 := @4 @72 +@458 := @4 @74 +@460 := @80 @35 @37 +@465 := @429 @86 @75 @77 @37 @10 +@468 := @429 @178 @86 @75 +@470 := @387 @77 @35 +@471 := @468 @470 +@472 := @385 @74 +@474 := @472 @79 @37 +@484 := {p : @31} -> + {c : @32} -> + {A : @33} -> + {v : @72} -> {t : @74} -> {vs : @457} -> {ts : @458} -> (h : @460) -> (hs : @465) -> @471 @474 +@486 := LexLeanPreservation.Rust.wtl_cons @0 +@504 := {c : @32} -> + {A : @33} -> + {v : @72} -> + {t : @74} -> + {vs : @457} -> + {ts : @458} -> (h : @107 @35 @37) -> (hs : @440 @75 @77 @37 @10) -> @440 @86 @75 @470 @474 +@505 := @486 @1 +@520 := {A : @33} -> + {v : @72} -> + {t : @74} -> + {vs : @457} -> {ts : @458} -> (h : @123 @35 @37) -> (hs : @448 @77 @37 @10) -> @448 @75 @470 @474 +@521 := @505 @2 +@523 := @65 @35 @37 +@525 := @454 @37 @10 +@533 := {v : @72} -> + {t : @74} -> {vs : @457} -> {ts : @458} -> (h : @523) -> (hs : @525) -> @454 @470 @474 +@534 := @521 @22 +@535 := @21 @79 +@537 := @65 @535 @37 +@538 := @21 @75 +@539 := @387 @538 +@547 := {t : @74} -> {vs : @457} -> {ts : @458} -> (h : @537) -> (hs : @525) -> @454 (@539 @35) @474 +@548 := @534 @29 +@549 := @21 @35 +@551 := @65 @549 @29 +@552 := @21 @77 +@553 := @387 @552 +@555 := @454 (@553 @35) +@556 := @472 @29 +@557 := @556 @37 +@562 := {vs : @457} -> {ts : @458} -> (h : @551) -> (hs : @525) -> @555 @557 +@563 := @548 @386 +@564 := @21 @37 +@566 := @65 @564 @29 +@567 := @455 @10 +@569 := @387 @535 @386 +@570 := @454 @569 +@574 := {ts : @458} -> (h : @566) -> (hs : @567) -> @570 @557 +@575 := @563 @409 +@577 := @387 @549 @386 +@578 := @454 @577 +@579 := @556 @409 +@582 := (h : @383) -> (hs : @456) -> @578 @579 +@583 := @575 @381 +@585 := @387 @564 @386 +@586 := @454 @585 +@588 := (hs : @456) -> @586 @579 +@589 := @583 @453 +@590 := @454 @389 +@591 := @590 @579 +@592 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.denoteEntry +@593 := @592 @10 +@594 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.entryFits +@595 := @594 @10 +@597 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.entryValue @10 +@599 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.entry @10 +@600 := Bool +@601 := Ne.{1} +@602 := LexLeanPreservation.Obs +@603 := @601 @602 +@604 := LexLeanPreservation.Rel +@607 := @603 (@604 @10 @30) +@608 := LexLeanPreservation.Obs.stuck +@611 := (f : @600) -> (v : @72) -> @607 @608 +@613 := LexLeanPreservation.Rust.rel_ne_stuck @595 +@619 := (v : @72) -> @603 (@604 (@594 @37) @30) @608 +@620 := @613 @597 +@624 := @603 (@604 @595 @597) @608 +@625 := @4 @392 +@626 := LexLeanPreservation.Rust.FunSem +@632 := (n : @390) -> @626 @176 @178 @86 @30 @75 +@633 := Eq.{1} +@634 := Option.{0} +@635 := @634 @404 +@636 := @633 @635 +@643 := LexLeanRuntime.index (@4 @404) @404 (LexLeanRuntime.instIndexableList @404) +@647 := @636 (@643 (@405 @176) @75) +@648 := Option.some.{0} +@649 := @648 @404 +@650 := @649 @77 +@651 := @647 @650 +@655 := @429 @185 @176 @178 @77 +@656 := LexLeanTarget.TargetSyntax.Function.types +@657 := @656 @75 +@658 := @655 @657 +@659 := @634 @625 +@660 := @633 @659 +@661 := LexLeanTarget.TargetSemantics.bindAll +@662 := LexLeanTarget.TargetSyntax.Function.parameters +@667 := @660 (@661 (@662 @86) @75 @399) +@668 := @648 @625 +@669 := @668 @77 +@670 := @667 @669 +@671 := @634 @600 +@672 := @633 @671 +@673 := LexLeanPreservation.Rust.fnFallible +@676 := @672 (@673 @194 @176) +@677 := @648 @600 +@678 := @677 @77 +@679 := @676 @678 +@680 := LexLeanPreservation.RunConv +@681 := #13 +@685 := @680 @681 @185 @178 @77 +@687 := @603 @75 @608 +@688 := Exists.{1} +@689 := LexLeanPreservation.Rust.ROut +@690 := @688 @689 +@691 := And +@692 := LexLeanPreservation.Rust.RealizesFn +@696 := @691 (@692 @176 @178 @30) +@697 := LexLeanPreservation.Rust.RCI +@699 := @697 #15 +@700 := LexLeanPreservation.Rust.fnIdent +@701 := @700 @681 +@708 := (hne : @687) -> @690 (fun (ro : @689) => @696 (@699 @701 @194 @30)) +@723 := {p : @31} -> + {c : @32} -> + {A : @33} -> + {f : @390} -> + {fn : @404} -> + {args : @457} -> + {env : @625} -> + {F : @600} -> + {o : @602} -> + (hB : @632) -> + (hfn : @651) -> (hwt : @658) -> (hbind : @670) -> (hF : @679) -> (hA : @685) -> @708 +@725 := LexLeanPreservation.Rust.compose @0 +@726 := @626 @0 +@731 := (n : @390) -> @726 @178 @86 @30 @75 +@732 := @643 @406 +@735 := @636 (@732 @75) @650 +@739 := @440 @176 @178 @77 @657 +@740 := @680 @0 +@743 := @740 @185 @178 @77 +@757 := {c : @32} -> + {A : @33} -> + {f : @390} -> + {fn : @404} -> + {args : @457} -> + {env : @625} -> + {F : @600} -> + {o : @602} -> + (hB : @731) -> + (hfn : @735) -> (hwt : @739) -> (hbind : @670) -> (hF : @679) -> (hA : @743) -> @708 +@758 := @725 @1 +@759 := @726 @1 +@763 := (n : @390) -> @759 @86 @30 @75 +@766 := @448 @178 @77 @657 +@767 := @673 @1 +@770 := @672 (@767 @176) @678 +@771 := @697 @1 +@781 := (hbind : @670) -> + (hF : @770) -> (hA : @743) -> (hne : @687) -> @690 (fun (ro : @689) => @696 (@771 @701 @194 @30)) +@791 := {A : @33} -> + {f : @390} -> + {fn : @404} -> + {args : @457} -> + {env : @625} -> {F : @600} -> {o : @602} -> (hB : @763) -> (hfn : @735) -> (hwt : @766) -> @781 +@792 := @758 @2 +@794 := @759 @2 @30 +@796 := (n : @390) -> @794 @75 +@797 := @454 @77 +@798 := @797 @657 +@807 := {f : @390} -> + {fn : @404} -> + {args : @457} -> + {env : @625} -> {F : @600} -> {o : @602} -> (hB : @796) -> (hfn : @735) -> (hwt : @798) -> @781 +@808 := @792 @407 +@810 := (n : @390) -> @794 @407 +@811 := @732 @407 +@812 := @636 @811 +@813 := @812 @650 +@814 := @767 @407 +@815 := @672 @814 +@816 := @815 @678 +@817 := @740 @407 +@819 := @817 @178 @77 +@821 := @771 (@700 @407) +@829 := (hF : @816) -> (hA : @819) -> (hne : @687) -> @690 (fun (ro : @689) => @696 (@821 @194 @30)) +@838 := {fn : @404} -> + {args : @457} -> + {env : @625} -> + {F : @600} -> {o : @602} -> (hB : @810) -> (hfn : @813) -> (hwt : @798) -> (hbind : @670) -> @829 +@839 := @808 @424 +@841 := @812 (@649 @424) +@842 := @656 @424 +@843 := @797 @842 +@845 := @661 (@662 @424) +@857 := {args : @457} -> + {env : @625} -> + {F : @600} -> + {o : @602} -> + (hB : @810) -> (hfn : @841) -> (hwt : @843) -> (hbind : @660 (@845 @75 @399) @669) -> @829 +@858 := @839 @389 +@859 := @539 @386 +@861 := @454 @859 @842 +@864 := @387 (@21 @86) @386 +@868 := @660 (@845 @864 @399) @669 +@871 := @387 (@21 @176) @386 +@892 := {env : @625} -> + {F : @600} -> + {o : @602} -> + (hB : @810) -> + (hfn : @841) -> + (hwt : @861) -> + (hbind : @868) -> + (hF : @816) -> + (hA : @817 @871 @77) -> + (hne : @687) -> @690 (fun (ro : @689) => @696 (@821 (@387 (@21 #12) @386) @30)) +@893 := @858 @402 +@894 := @553 @386 +@896 := @454 @894 @842 +@904 := @660 (@845 @859 @399) (@668 (@400 (@397 @538) @399)) +@907 := @387 (@21 @178) @386 +@926 := {F : @600} -> + {o : @602} -> + (hB : @810) -> + (hfn : @841) -> + (hwt : @896) -> + (hbind : @904) -> + (hF : @816) -> + (hA : @817 @907 @77) -> + (hne : @687) -> @690 (fun (ro : @689) => @696 (@821 (@387 (@21 @194) @386) @30)) +@927 := @893 @403 +@928 := @570 @842 +@936 := @660 (@845 @894 @399) (@668 (@400 (@397 @552) @399)) +@938 := @815 (@677 @403) +@940 := @817 @864 @77 +@941 := @692 @403 +@960 := {o : @602} -> + (hB : @810) -> + (hfn : @841) -> + (hwt : @928) -> + (hbind : @936) -> + (hF : @938) -> + (hA : @940) -> + (hne : @687) -> @690 (fun (ro : @689) => @691 (@941 @178 @30) (@821 (@387 (@21 @185) @386) @30)) +@961 := @927 @593 +@962 := @578 @842 +@970 := @660 (@845 @569 @399) (@668 (@400 (@397 @535) @399)) +@971 := @817 @859 +@972 := @592 @75 +@973 := @971 @972 +@974 := @592 @86 +@992 := (hB : @810) -> + (hfn : @841) -> + (hwt : @962) -> + (hbind : @970) -> + (hF : @938) -> + (hA : @973) -> + (hne : @603 @974 @608) -> @690 (fun (ro : @689) => @691 (@941 (@592 @176) @30) (@821 @871 @30)) +@993 := @961 @428 +@994 := @586 @842 +@1002 := @660 (@845 @577 @399) (@668 (@400 (@397 @549) @399)) +@1003 := @817 @894 +@1004 := @592 @77 +@1022 := (hfn : @841) -> + (hwt : @994) -> + (hbind : @1002) -> + (hF : @938) -> + (hA : @1003 @1004) -> + (hne : @603 @972 @608) -> @690 (fun (ro : @689) => @691 (@941 (@592 @178) @30) (@821 @907 @30)) +@1023 := Eq.refl.{1} +@1026 := @993 (@1023 @635 @811) +@1027 := @590 @842 +@1035 := @660 (@845 @585 @399) (@668 (@400 (@397 @564) @399)) +@1036 := @817 @569 +@1037 := @592 @79 +@1053 := (hwt : @1027) -> + (hbind : @1035) -> + (hF : @938) -> + (hA : @1036 @1037) -> + (hne : @603 @1004 @608) -> @690 (fun (ro : @689) => @691 (@941 @974 @30) (@821 @864 @30)) +@1054 := @1026 @589 +@1056 := @845 @389 @399 +@1059 := @660 @1056 (@668 @402) +@1060 := @817 @577 +@1061 := @592 @35 +@1076 := (hbind : @1059) -> + (hF : @938) -> + (hA : @1060 @1061) -> + (hne : @603 @1037 @608) -> @690 (fun (ro : @689) => @691 (@941 @972 @30) (@821 @859 @30)) +@1079 := @1054 (@1023 @659 @1056) +@1080 := @817 @585 +@1081 := @592 @37 +@1095 := (hF : @938) -> + (hA : @1080 @1081) -> + (hne : @603 @1061 @608) -> @690 (fun (ro : @689) => @691 (@941 @1004 @30) (@821 @894 @30)) +@1098 := @1079 (@1023 @671 @814) +@1100 := @817 @389 @593 +@1102 := @603 @1081 @608 +@1103 := @941 @1037 +@1105 := @691 (@1103 @30) +@1106 := @821 @569 +@1107 := @1106 @30 +@1112 := (hA : @1100) -> (hne : @1102) -> @690 (fun (ro : @689) => @1105 @1107) +@1113 := @1098 @599 +@1115 := @603 @593 @608 +@1116 := @941 @1061 +@1118 := @691 (@1116 @30) +@1119 := @821 @577 +@1124 := (hne : @1115) -> @690 (fun (ro : @689) => @1118 (@1119 @30)) +@1125 := @1113 @620 +@1128 := @691 (@941 @1081 @30) +@1130 := @821 @585 @30 +@1131 := @1128 @1130 +@1133 := @690 (fun (ro : @689) => @1131) +@1134 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.accepts +@1135 := @1134 @10 +@1136 := LexLeanPreservation.someObs +@1137 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.denote +@1139 := @1136 (@1137 @10) +@1142 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none +@1143 := Not +@1144 := @1143 @1135 +@1145 := @1134 @37 +@1147 := @1136 (@1137 @37) +@1148 := @1143 @1145 +@1153 := @1145 -> @941 (@1136 (@1137 @35)) @10 +@1154 := @941 @1142 +@1155 := @1154 @10 +@1156 := @1148 -> @1155 +@1158 := @691 @1153 @1156 +@1162 := @690 (fun (__e_ro : @689) => @691 @1130 @1158) +@1163 := fun (__e_ro : @689) => @1131 +@1164 := @1116 @10 +@1165 := @1119 @10 +@1166 := And.left +@1167 := And.right +@1170 := @1166 @1164 @1165 @30 +@1173 := @1167 @1164 @1165 @30 +@1174 := @941 @30 +@1176 := fun (__e_o : @602) => @1174 @37 +@1177 := Eq.subst.{1} +@1178 := @1134 @35 +@1179 := @1143 @1178 +@1182 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.entry_accepts @79 @30 +@1184 := @1136 (@1137 @79) +@1189 := @1166 (@1103 @37) (@1106 @37) @10 +@1191 := fun (__e_o : @602) => @1174 @35 +@1194 := @1177 @602 @1191 @1037 +@1198 := fun (__e_h : @1178) => @1194 @1184 @1182 @1189 +@1201 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.entry_refuses @79 @30 +@1205 := fun (__e_h : @1179) => @1194 @1142 @1201 @1189 +@1206 := And.intro +@1209 := @1178 -> @941 @1184 @37 +@1211 := @1179 -> @1154 @37 +@1213 := @691 @1209 @1211 +@1217 := @1206 @1209 @1211 @1198 @1205 +@1221 := @1206 @1165 @1213 @1173 @1217 +@1222 := Exists.intro.{1} +@1223 := @691 @1107 +@1224 := @1134 @79 +@1235 := fun (__e_ro : @689) => + @1223 (@691 (@1224 -> @941 (@1136 (@1137 @77)) @10) (@1143 @1224 -> @1155)) +@1239 := @1222 @689 @1235 @10 @1221 +@1241 := @691 @1164 @1165 +@1243 := fun (__e_ro : @689) => fun (__e_hand : @1131) => @1239 +@1249 := Exists.elim.{1} @689 @1163 @1162 @1125 @1243 +@1253 := LexLeanPreservation.Rust.RepresentableL (@387 @370 @386) +@1254 := (__e_hrep : @1253) -> @1162 +@1255 := fun (__e_hrep : @1253) => @1249 +@1256 := (g : @9) -> @1254 +@1257 := fun (g : @9) => @1255 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R8/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R8/Compose/RustStd.lean deleted file mode 100644 index 416d25335..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R8/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd - -/-- The rendering of the root's entry, invoked on the encoded arguments, -realizes the encoded source result when the arguments satisfy §17.12's -invariants, and refuses them with `none` otherwise. -/ -theorem root (a : (List (Prod (Prod Nat String) Bool))) (k : (Prod Nat String)) (i : (List (Prod Int8 Nat))) (j : Int8) (b : (List (Prod Bool Nat))) (c : Bool) (d : (List (Prod Int Nat))) (e : Int) (u : (List (Prod UInt64 Nat))) (w : UInt64) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.string) _root_.LexLeanTarget.TargetSyntax.Value.bool)) a), ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.string) k), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.i8 _root_.LexLeanTarget.TargetSyntax.Value.nat)) i), (_root_.LexLeanTarget.TargetSyntax.Value.i8 j), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.nat)) b), (_root_.LexLeanTarget.TargetSyntax.Value.bool c), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.int _root_.LexLeanTarget.TargetSyntax.Value.nat)) d), (_root_.LexLeanTarget.TargetSyntax.Value.int e), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.u64 _root_.LexLeanTarget.TargetSyntax.Value.nat)) u), (_root_.LexLeanTarget.TargetSyntax.Value.u64 w)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 13) [((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.string) _root_.LexLeanTarget.TargetSyntax.Value.bool)) a), ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.string) k), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.i8 _root_.LexLeanTarget.TargetSyntax.Value.nat)) i), (_root_.LexLeanTarget.TargetSyntax.Value.i8 j), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.bool _root_.LexLeanTarget.TargetSyntax.Value.nat)) b), (_root_.LexLeanTarget.TargetSyntax.Value.bool c), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.int _root_.LexLeanTarget.TargetSyntax.Value.nat)) d), (_root_.LexLeanTarget.TargetSyntax.Value.int e), ((_root_.LexLeanPreservation.encList (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.u64 _root_.LexLeanTarget.TargetSyntax.Value.nat)) u), (_root_.LexLeanTarget.TargetSyntax.Value.u64 w)] __e_ro ∧ - (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.accepts a k i j b c d e u w → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.denote a k i j b c d e u w)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.accepts a k i j b c d e u w → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.Obs.value _root_.LexLeanTarget.TargetSyntax.Value.none) __e_ro) := - match _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd.root __e_n 13) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_string) _root_.LexLeanPreservation.Rust.wt_bool)) a) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_string) k) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_i8 _root_.LexLeanPreservation.Rust.wt_nat)) i) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_i8 j) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_bool _root_.LexLeanPreservation.Rust.wt_nat)) b) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_bool c) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_int _root_.LexLeanPreservation.Rust.wt_nat)) d) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_int e) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_u64 _root_.LexLeanPreservation.Rust.wt_nat)) u) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u64 w) _root_.LexLeanPreservation.Rust.wtl_nil)))))))))) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.entry a k i j b c d e u w) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) with - | ⟨__e_ro, __e_hr, __e_hc⟩ => ⟨__e_ro, __e_hc, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.entry_accepts a k i j b c d e u w __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.entry_refuses a k i j b c d e u w __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R8/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R8/Compose/RustStd.lex.tex new file mode 100644 index 000000000..645a884b7 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R8/Compose/RustStd.lex.tex @@ -0,0 +1,1570 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd.root : @3073 := @3074 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd.flags +@3 := Nat +@4 := String +@5 := Prod.{0, 0} +@6 := @5 @3 +@7 := @6 @4 +@8 := Bool +@9 := @5 @7 +@10 := @9 @8 +@11 := List.{0} +@12 := @11 @10 +@13 := #10 +@14 := LexLeanTarget.TargetSyntax.Value.nat +@15 := LexLeanTarget.TargetSyntax.Value.string +@16 := LexLeanPreservation.encPair +@17 := @16 @3 +@18 := @17 @4 +@19 := @18 @14 +@20 := @19 @15 +@21 := LexLeanTarget.TargetSyntax.Value.bool +@22 := @16 @7 +@23 := @22 @8 +@24 := @23 @20 +@25 := @24 @21 +@26 := LexLeanPreservation.encList +@27 := @26 @10 +@28 := @27 @25 +@29 := @28 @13 +@30 := LexLeanTarget.TargetSyntax.Ty.nat +@31 := LexLeanTarget.TargetSyntax.Ty.string +@32 := LexLeanTarget.TargetSyntax.Ty.pair +@33 := @32 @30 +@34 := @33 @31 +@35 := LexLeanTarget.TargetSyntax.Ty.bool +@36 := @32 @34 +@37 := @36 @35 +@38 := LexLeanTarget.TargetSyntax.Ty.list +@39 := @38 @37 +@40 := #0 +@41 := LexLeanTarget.TargetSyntax.Program +@42 := LexLeanPreservation.Rust.RCrate +@43 := LexLeanPreservation.Rust.Flags +@44 := LexLeanPreservation.Rust.WT +@45 := #3 +@46 := @44 @45 +@47 := #2 +@48 := @46 @47 +@49 := #1 +@50 := @48 @49 +@51 := @14 @40 +@57 := {p : @41} -> {c : @42} -> {A : @43} -> (n : @3) -> @50 @51 @30 +@59 := LexLeanPreservation.Rust.wt_nat @0 +@60 := @44 @0 +@62 := @60 @47 @49 +@67 := {c : @42} -> {A : @43} -> (n : @3) -> @62 @51 @30 +@68 := @59 @1 +@69 := @60 @1 +@70 := @69 @49 +@74 := {A : @43} -> (n : @3) -> @70 @51 @30 +@75 := @68 @2 +@76 := @69 @2 +@77 := @76 @51 +@78 := @77 @30 +@79 := (n : @3) -> @78 +@81 := fun (__x : @3) => @75 @40 +@82 := @15 @40 +@88 := {p : @41} -> {c : @42} -> {A : @43} -> (s : @4) -> @50 @82 @31 +@90 := LexLeanPreservation.Rust.wt_string @0 +@95 := {c : @42} -> {A : @43} -> (s : @4) -> @62 @82 @31 +@96 := @90 @1 +@100 := {A : @43} -> (s : @4) -> @70 @82 @31 +@101 := @96 @2 +@102 := @76 @82 +@103 := @102 @31 +@104 := (s : @4) -> @103 +@106 := fun (__x : @4) => @101 @40 +@107 := Sort 1 +@108 := LexLeanTarget.TargetSyntax.Value +@109 := (a._@._internal._hyg.#0 : @49) -> @108 +@110 := LexLeanTarget.TargetSyntax.Ty +@111 := #5 +@112 := #9 +@113 := @44 @112 +@114 := #8 +@115 := @113 @114 +@116 := #7 +@117 := @115 @116 +@118 := #4 +@119 := @118 @40 +@122 := (x : @111) -> @117 @119 @47 +@128 := (x : @111) -> @44 @13 @112 @114 @119 @47 +@129 := @5 @116 +@130 := #6 +@131 := @129 @130 +@132 := #11 +@135 := @44 @132 @13 @112 +@140 := @16 @114 @116 @130 @111 @40 +@141 := @135 @140 +@143 := @32 @118 @45 +@156 := {p : @41} -> + {c : @42} -> + {A : @43} -> + {α : @107} -> + {β : @107} -> + {ea : @109} -> + {eb : @109} -> {s : @110} -> {t : @110} -> (ha : @122) -> (hb : @128) -> (x : @131) -> @141 @143 +@158 := LexLeanPreservation.Rust.wt_encPair @0 +@183 := {c : @42} -> + {A : @43} -> + {α : @107} -> + {β : @107} -> + {ea : @109} -> + {eb : @109} -> + {s : @110} -> + {t : @110} -> + (ha : (x : @111) -> @60 @114 @116 @119 @47) -> + (hb : (x : @111) -> @60 @112 @114 @119 @47) -> (x : @131) -> @60 @13 @112 @140 @143 +@184 := @158 @1 +@205 := {A : @43} -> + {α : @107} -> + {β : @107} -> + {ea : @109} -> + {eb : @109} -> + {s : @110} -> + {t : @110} -> + (ha : (x : @111) -> @69 @116 @119 @47) -> + (hb : (x : @111) -> @69 @114 @119 @47) -> (x : @131) -> @69 @112 @140 @143 +@206 := @184 @2 +@208 := @76 @119 @47 +@209 := (x : @111) -> @208 +@220 := {α : @107} -> + {β : @107} -> + {ea : @109} -> + {eb : @109} -> + {s : @110} -> {t : @110} -> (ha : @209) -> (hb : @209) -> (x : @131) -> @76 @140 @143 +@221 := @206 @3 +@222 := (a._@._internal._hyg.#0 : @3) -> @108 +@223 := (x : @3) -> @208 +@238 := {β : @107} -> + {ea : @222} -> + {eb : @109} -> + {s : @110} -> + {t : @110} -> (ha : @223) -> (hb : @209) -> (x : @6 @130) -> @76 (@17 @116 @130 @111 @40) @143 +@239 := @221 @4 +@240 := (a._@._internal._hyg.#0 : @4) -> @108 +@241 := (x : @4) -> @208 +@253 := {ea : @222} -> + {eb : @240} -> + {s : @110} -> {t : @110} -> (ha : @223) -> (hb : @241) -> (x : @7) -> @76 (@18 @130 @111 @40) @143 +@254 := @239 @14 +@256 := (x : @3) -> @77 @47 +@266 := {eb : @240} -> + {s : @110} -> {t : @110} -> (ha : @256) -> (hb : @241) -> (x : @7) -> @76 (@19 @111 @40) @143 +@267 := @254 @15 +@269 := (x : @4) -> @102 @47 +@271 := @76 (@20 @40) +@277 := {s : @110} -> {t : @110} -> (ha : @256) -> (hb : @269) -> (x : @7) -> @271 @143 +@278 := @267 @30 +@279 := (x : @3) -> @78 +@285 := {t : @110} -> (ha : @279) -> (hb : @269) -> (x : @7) -> @271 (@33 @45) +@286 := @278 @31 +@287 := (x : @4) -> @103 +@289 := (x : @7) -> @271 @34 +@291 := (ha : @279) -> (hb : @287) -> @289 +@293 := @286 @81 @106 +@295 := fun (__x : @7) => @293 @40 +@296 := @21 @40 +@302 := {p : @41} -> {c : @42} -> {A : @43} -> (b : @8) -> @50 @296 @35 +@304 := LexLeanPreservation.Rust.wt_bool @0 +@309 := {c : @42} -> {A : @43} -> (b : @8) -> @62 @296 @35 +@310 := @304 @1 +@314 := {A : @43} -> (b : @8) -> @70 @296 @35 +@315 := @310 @2 +@316 := @76 @296 +@317 := @316 @35 +@318 := (b : @8) -> @317 +@320 := fun (__x : @8) => @315 @40 +@321 := @206 @7 +@322 := (a._@._internal._hyg.#0 : @7) -> @108 +@323 := (x : @7) -> @208 +@338 := {β : @107} -> + {ea : @322} -> + {eb : @109} -> + {s : @110} -> + {t : @110} -> (ha : @323) -> (hb : @209) -> (x : @9 @130) -> @76 (@22 @116 @130 @111 @40) @143 +@339 := @321 @8 +@340 := (a._@._internal._hyg.#0 : @8) -> @108 +@341 := (x : @8) -> @208 +@353 := {ea : @322} -> + {eb : @340} -> + {s : @110} -> + {t : @110} -> (ha : @323) -> (hb : @341) -> (x : @10) -> @76 (@23 @130 @111 @40) @143 +@354 := @339 @20 +@356 := (x : @7) -> @271 @47 +@366 := {eb : @340} -> + {s : @110} -> {t : @110} -> (ha : @356) -> (hb : @341) -> (x : @10) -> @76 (@24 @111 @40) @143 +@367 := @354 @21 +@369 := (x : @8) -> @316 @47 +@371 := @76 (@25 @40) +@377 := {s : @110} -> {t : @110} -> (ha : @356) -> (hb : @369) -> (x : @10) -> @371 @143 +@378 := @367 @34 +@384 := {t : @110} -> (ha : @289) -> (hb : @369) -> (x : @10) -> @371 (@36 @45) +@385 := @378 @35 +@386 := (x : @8) -> @317 +@388 := (x : @10) -> @371 @37 +@390 := (ha : @289) -> (hb : @386) -> @388 +@394 := fun (__x : @10) => @385 @295 @320 @40 +@395 := (a._@._internal._hyg.#0 : @40) -> @108 +@398 := @44 @130 @111 @118 +@399 := @47 @40 +@402 := (x : @47) -> @398 @399 @49 +@403 := @11 @45 +@406 := @44 @116 @130 @111 +@409 := @26 @118 @45 @40 +@410 := @406 @409 +@411 := @38 @47 +@420 := {p : @41} -> + {c : @42} -> + {A : @43} -> {α : @107} -> {e : @395} -> {t : @110} -> (h : @402) -> (xs : @403) -> @410 @411 +@422 := LexLeanPreservation.Rust.wt_encList @0 +@424 := @60 @111 @118 +@438 := {c : @42} -> + {A : @43} -> + {α : @107} -> + {e : @395} -> + {t : @110} -> (h : (x : @47) -> @424 @399 @49) -> (xs : @403) -> @60 @130 @111 @409 @411 +@439 := @422 @1 +@440 := @69 @118 +@452 := {A : @43} -> + {α : @107} -> + {e : @395} -> {t : @110} -> (h : (x : @47) -> @440 @399 @49) -> (xs : @403) -> @69 @111 @409 @411 +@453 := @439 @2 +@455 := @76 @399 @49 +@463 := {α : @107} -> + {e : @395} -> {t : @110} -> (h : (x : @47) -> @455) -> (xs : @403) -> @76 @409 @411 +@464 := @453 @10 +@474 := {e : (a._@._internal._hyg.#0 : @10) -> @108} -> + {t : @110} -> (h : (x : @10) -> @455) -> (xs : @12) -> @76 (@27 @45 @40) @411 +@475 := @464 @25 +@477 := (x : @10) -> @371 @49 +@479 := @76 (@28 @40) +@483 := {t : @110} -> (h : @477) -> (xs : @12) -> @479 @411 +@484 := @475 @37 +@487 := (h : @388) -> (xs : @12) -> @479 @39 +@489 := @484 @394 @13 +@491 := @76 @29 @39 +@492 := @20 @112 +@493 := @293 @112 +@495 := @76 @492 @34 +@496 := Int8 +@497 := @5 @496 +@498 := @497 @3 +@499 := @11 @498 +@500 := LexLeanTarget.TargetSyntax.Value.i8 +@501 := @16 @496 +@502 := @501 @3 +@503 := @502 @500 +@504 := @503 @14 +@505 := @26 @498 +@506 := @505 @504 +@507 := @506 @114 +@508 := LexLeanTarget.TargetSyntax.Ty.fixed +@510 := @508 LexLeanTarget.TargetSyntax.IntKind.i8 +@511 := @32 @510 +@512 := @511 @30 +@513 := @38 @512 +@514 := @500 @40 +@520 := {p : @41} -> {c : @42} -> {A : @43} -> (x : @496) -> @50 @514 @510 +@522 := LexLeanPreservation.Rust.wt_i8 @0 +@527 := {c : @42} -> {A : @43} -> (x : @496) -> @62 @514 @510 +@528 := @522 @1 +@532 := {A : @43} -> (x : @496) -> @70 @514 @510 +@533 := @528 @2 +@534 := @76 @514 +@536 := (x : @496) -> @534 @510 +@538 := fun (__x : @496) => @533 @40 +@539 := @206 @496 +@540 := (a._@._internal._hyg.#0 : @496) -> @108 +@541 := (x : @496) -> @208 +@556 := {β : @107} -> + {ea : @540} -> + {eb : @109} -> + {s : @110} -> + {t : @110} -> (ha : @541) -> (hb : @209) -> (x : @497 @130) -> @76 (@501 @116 @130 @111 @40) @143 +@557 := @539 @3 +@569 := {ea : @540} -> + {eb : @222} -> + {s : @110} -> + {t : @110} -> (ha : @541) -> (hb : @223) -> (x : @498) -> @76 (@502 @130 @111 @40) @143 +@570 := @557 @500 +@572 := (x : @496) -> @534 @47 +@582 := {eb : @222} -> + {s : @110} -> {t : @110} -> (ha : @572) -> (hb : @223) -> (x : @498) -> @76 (@503 @111 @40) @143 +@583 := @570 @14 +@585 := @76 (@504 @40) +@591 := {s : @110} -> {t : @110} -> (ha : @572) -> (hb : @256) -> (x : @498) -> @585 @143 +@592 := @583 @510 +@598 := {t : @110} -> (ha : @536) -> (hb : @256) -> (x : @498) -> @585 (@511 @45) +@599 := @592 @30 +@601 := (x : @498) -> @585 @512 +@603 := (ha : @536) -> (hb : @279) -> @601 +@607 := fun (__x : @498) => @599 @538 @81 @40 +@608 := @453 @498 +@618 := {e : (a._@._internal._hyg.#0 : @498) -> @108} -> + {t : @110} -> (h : (x : @498) -> @455) -> (xs : @499) -> @76 (@505 @45 @40) @411 +@619 := @608 @504 +@621 := (x : @498) -> @585 @49 +@623 := @76 (@506 @40) +@627 := {t : @110} -> (h : @621) -> (xs : @499) -> @623 @411 +@628 := @619 @512 +@631 := (h : @601) -> (xs : @499) -> @623 @513 +@633 := @628 @607 @114 +@635 := @76 @507 @513 +@636 := @500 @116 +@637 := @533 @116 +@639 := @76 @636 @510 +@640 := @5 @8 +@641 := @640 @3 +@642 := @11 @641 +@643 := @16 @8 +@644 := @643 @3 +@645 := @644 @21 +@646 := @645 @14 +@647 := @26 @641 +@648 := @647 @646 +@649 := @648 @130 +@650 := @32 @35 +@651 := @650 @30 +@652 := @38 @651 +@653 := @206 @8 +@668 := {β : @107} -> + {ea : @340} -> + {eb : @109} -> + {s : @110} -> + {t : @110} -> (ha : @341) -> (hb : @209) -> (x : @640 @130) -> @76 (@643 @116 @130 @111 @40) @143 +@669 := @653 @3 +@681 := {ea : @340} -> + {eb : @222} -> + {s : @110} -> + {t : @110} -> (ha : @341) -> (hb : @223) -> (x : @641) -> @76 (@644 @130 @111 @40) @143 +@682 := @669 @21 +@692 := {eb : @222} -> + {s : @110} -> {t : @110} -> (ha : @369) -> (hb : @223) -> (x : @641) -> @76 (@645 @111 @40) @143 +@693 := @682 @14 +@695 := @76 (@646 @40) +@701 := {s : @110} -> {t : @110} -> (ha : @369) -> (hb : @256) -> (x : @641) -> @695 @143 +@702 := @693 @35 +@708 := {t : @110} -> (ha : @386) -> (hb : @256) -> (x : @641) -> @695 (@650 @45) +@709 := @702 @30 +@711 := (x : @641) -> @695 @651 +@713 := (ha : @386) -> (hb : @279) -> @711 +@717 := fun (__x : @641) => @709 @320 @81 @40 +@718 := @453 @641 +@728 := {e : (a._@._internal._hyg.#0 : @641) -> @108} -> + {t : @110} -> (h : (x : @641) -> @455) -> (xs : @642) -> @76 (@647 @45 @40) @411 +@729 := @718 @646 +@731 := (x : @641) -> @695 @49 +@733 := @76 (@648 @40) +@737 := {t : @110} -> (h : @731) -> (xs : @642) -> @733 @411 +@738 := @729 @651 +@741 := (h : @711) -> (xs : @642) -> @733 @652 +@743 := @738 @717 @130 +@745 := @76 @649 @652 +@746 := @21 @111 +@747 := @315 @111 +@749 := @76 @746 @35 +@750 := Int +@751 := @5 @750 +@752 := @751 @3 +@753 := @11 @752 +@754 := LexLeanTarget.TargetSyntax.Value.int +@755 := @16 @750 +@756 := @755 @3 +@757 := @756 @754 +@758 := @757 @14 +@759 := @26 @752 +@760 := @759 @758 +@761 := @760 @118 +@762 := LexLeanTarget.TargetSyntax.Ty.int +@763 := @32 @762 +@764 := @763 @30 +@765 := @38 @764 +@766 := @754 @40 +@772 := {p : @41} -> {c : @42} -> {A : @43} -> (n : @750) -> @50 @766 @762 +@774 := LexLeanPreservation.Rust.wt_int @0 +@779 := {c : @42} -> {A : @43} -> (n : @750) -> @62 @766 @762 +@780 := @774 @1 +@784 := {A : @43} -> (n : @750) -> @70 @766 @762 +@785 := @780 @2 +@786 := @76 @766 +@787 := @786 @762 +@788 := (n : @750) -> @787 +@790 := fun (__x : @750) => @785 @40 +@791 := @206 @750 +@792 := (a._@._internal._hyg.#0 : @750) -> @108 +@793 := (x : @750) -> @208 +@808 := {β : @107} -> + {ea : @792} -> + {eb : @109} -> + {s : @110} -> + {t : @110} -> (ha : @793) -> (hb : @209) -> (x : @751 @130) -> @76 (@755 @116 @130 @111 @40) @143 +@809 := @791 @3 +@821 := {ea : @792} -> + {eb : @222} -> + {s : @110} -> + {t : @110} -> (ha : @793) -> (hb : @223) -> (x : @752) -> @76 (@756 @130 @111 @40) @143 +@822 := @809 @754 +@824 := (x : @750) -> @786 @47 +@834 := {eb : @222} -> + {s : @110} -> {t : @110} -> (ha : @824) -> (hb : @223) -> (x : @752) -> @76 (@757 @111 @40) @143 +@835 := @822 @14 +@837 := @76 (@758 @40) +@843 := {s : @110} -> {t : @110} -> (ha : @824) -> (hb : @256) -> (x : @752) -> @837 @143 +@844 := @835 @762 +@845 := (x : @750) -> @787 +@851 := {t : @110} -> (ha : @845) -> (hb : @256) -> (x : @752) -> @837 (@763 @45) +@852 := @844 @30 +@854 := (x : @752) -> @837 @764 +@856 := (ha : @845) -> (hb : @279) -> @854 +@860 := fun (__x : @752) => @852 @790 @81 @40 +@861 := @453 @752 +@871 := {e : (a._@._internal._hyg.#0 : @752) -> @108} -> + {t : @110} -> (h : (x : @752) -> @455) -> (xs : @753) -> @76 (@759 @45 @40) @411 +@872 := @861 @758 +@874 := (x : @752) -> @837 @49 +@876 := @76 (@760 @40) +@880 := {t : @110} -> (h : @874) -> (xs : @753) -> @876 @411 +@881 := @872 @764 +@884 := (h : @854) -> (xs : @753) -> @876 @765 +@886 := @881 @860 @118 +@888 := @76 @761 @765 +@889 := @754 @45 +@890 := @785 @45 +@892 := @76 @889 @762 +@893 := UInt64 +@894 := @5 @893 +@895 := @894 @3 +@896 := @11 @895 +@897 := LexLeanTarget.TargetSyntax.Value.u64 +@898 := @16 @893 +@899 := @898 @3 +@900 := @899 @897 +@901 := @900 @14 +@902 := @26 @895 +@903 := @902 @901 +@904 := @903 @47 +@906 := @508 LexLeanTarget.TargetSyntax.IntKind.u64 +@907 := @32 @906 +@908 := @907 @30 +@909 := @38 @908 +@910 := @897 @40 +@916 := {p : @41} -> {c : @42} -> {A : @43} -> (x : @893) -> @50 @910 @906 +@918 := LexLeanPreservation.Rust.wt_u64 @0 +@923 := {c : @42} -> {A : @43} -> (x : @893) -> @62 @910 @906 +@924 := @918 @1 +@928 := {A : @43} -> (x : @893) -> @70 @910 @906 +@929 := @924 @2 +@930 := @76 @910 +@932 := (x : @893) -> @930 @906 +@934 := fun (__x : @893) => @929 @40 +@935 := @206 @893 +@936 := (a._@._internal._hyg.#0 : @893) -> @108 +@937 := (x : @893) -> @208 +@952 := {β : @107} -> + {ea : @936} -> + {eb : @109} -> + {s : @110} -> + {t : @110} -> (ha : @937) -> (hb : @209) -> (x : @894 @130) -> @76 (@898 @116 @130 @111 @40) @143 +@953 := @935 @3 +@965 := {ea : @936} -> + {eb : @222} -> + {s : @110} -> + {t : @110} -> (ha : @937) -> (hb : @223) -> (x : @895) -> @76 (@899 @130 @111 @40) @143 +@966 := @953 @897 +@968 := (x : @893) -> @930 @47 +@978 := {eb : @222} -> + {s : @110} -> {t : @110} -> (ha : @968) -> (hb : @223) -> (x : @895) -> @76 (@900 @111 @40) @143 +@979 := @966 @14 +@981 := @76 (@901 @40) +@987 := {s : @110} -> {t : @110} -> (ha : @968) -> (hb : @256) -> (x : @895) -> @981 @143 +@988 := @979 @906 +@994 := {t : @110} -> (ha : @932) -> (hb : @256) -> (x : @895) -> @981 (@907 @45) +@995 := @988 @30 +@997 := (x : @895) -> @981 @908 +@999 := (ha : @932) -> (hb : @279) -> @997 +@1003 := fun (__x : @895) => @995 @934 @81 @40 +@1004 := @453 @895 +@1014 := {e : (a._@._internal._hyg.#0 : @895) -> @108} -> + {t : @110} -> (h : (x : @895) -> @455) -> (xs : @896) -> @76 (@902 @45 @40) @411 +@1015 := @1004 @901 +@1017 := (x : @895) -> @981 @49 +@1019 := @76 (@903 @40) +@1023 := {t : @110} -> (h : @1017) -> (xs : @896) -> @1019 @411 +@1024 := @1015 @908 +@1027 := (h : @997) -> (xs : @896) -> @1019 @909 +@1029 := @1024 @1003 @47 +@1031 := @76 @904 @909 +@1032 := @897 @49 +@1033 := @929 @49 +@1035 := @76 @1032 @906 +@1036 := List.nil.{0} +@1037 := List.cons.{0} +@1038 := @1036 @108 +@1039 := @1037 @108 +@1041 := @1039 @1032 @1038 +@1043 := @1039 @904 @1041 +@1045 := @1039 @889 @1043 +@1047 := @1039 @761 @1045 +@1049 := @1039 @746 @1047 +@1051 := @1039 @649 @1049 +@1053 := @1039 @636 @1051 +@1055 := @1039 @507 @1053 +@1057 := @1039 @492 @1055 +@1059 := @1039 @29 @1057 +@1060 := @6 @108 +@1061 := 9 +@1064 := Prod.mk.{0, 0} @3 @108 +@1065 := @1064 @1061 +@1066 := @1065 @1032 +@1068 := @1064 8 +@1069 := @1068 @904 +@1071 := @1064 7 +@1072 := @1071 @889 +@1074 := @1064 6 +@1075 := @1074 @761 +@1077 := @1064 5 +@1078 := @1077 @746 +@1080 := @1064 4 +@1081 := @1080 @649 +@1083 := @1064 3 +@1084 := @1083 @636 +@1086 := @1064 2 +@1087 := @1086 @507 +@1089 := @1064 1 +@1090 := @1089 @492 +@1092 := @1064 0 +@1093 := @1092 @29 +@1094 := @1036 @1060 +@1095 := @1037 @1060 +@1097 := @1095 @1093 @1094 +@1099 := @1095 @1090 @1097 +@1101 := @1095 @1087 @1099 +@1103 := @1095 @1084 @1101 +@1105 := @1095 @1081 @1103 +@1107 := @1095 @1078 @1105 +@1109 := @1095 @1075 @1107 +@1111 := @1095 @1072 @1109 +@1113 := @1095 @1069 @1111 +@1115 := @1095 @1066 @1113 +@1116 := Bool.false +@1117 := LexLeanTarget.TargetSyntax.Function +@1118 := LexLeanTarget.TargetSyntax.Program.functions +@1119 := @1118 @0 +@1120 := 13 +@1121 := @1036 @3 +@1122 := @1036 @110 +@1123 := LexLeanTarget.TargetSyntax.Ty.unit +@1124 := LexLeanTarget.TargetSyntax.Value.unit +@1127 := LexLeanTarget.TargetSyntax.Expr.value @1123 @1124 +@1132 := LexLeanTarget.TargetSyntax.Function.mk @1121 @1122 @1123 @1127 +@1137 := List.getD.{0} @1117 @1119 @1120 @1132 +@1141 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd.root @40 @1120 +@1142 := LexLeanPreservation.Rust.WTL +@1150 := {p : @41} -> {c : @42} -> {A : @43} -> @1142 @47 @49 @40 @1038 @1122 +@1152 := LexLeanPreservation.Rust.wtl_nil @0 +@1153 := @1142 @0 +@1159 := {c : @42} -> {A : @43} -> @1153 @49 @40 @1038 @1122 +@1160 := @1152 @1 +@1161 := @1153 @1 +@1165 := {A : @43} -> @1161 @40 @1038 @1122 +@1166 := @1160 @2 +@1167 := @1161 @2 +@1168 := @1167 @1038 +@1169 := @1168 @1122 +@1170 := @11 @108 +@1171 := @11 @110 +@1173 := @398 @45 @47 +@1178 := @1142 @116 @130 @111 @47 @49 +@1181 := @1142 @114 @116 @130 +@1183 := @1039 @111 @45 +@1184 := @1181 @1183 +@1185 := @1037 @110 +@1187 := @1185 @118 @47 +@1197 := {p : @41} -> + {c : @42} -> + {A : @43} -> + {v : @108} -> + {t : @110} -> {vs : @1170} -> {ts : @1171} -> (h : @1173) -> (hs : @1178) -> @1184 @1187 +@1199 := LexLeanPreservation.Rust.wtl_cons @0 +@1217 := {c : @42} -> + {A : @43} -> + {v : @108} -> + {t : @110} -> + {vs : @1170} -> + {ts : @1171} -> + (h : @424 @45 @47) -> (hs : @1153 @130 @111 @47 @49) -> @1153 @116 @130 @1183 @1187 +@1218 := @1199 @1 +@1233 := {A : @43} -> + {v : @108} -> + {t : @110} -> + {vs : @1170} -> + {ts : @1171} -> (h : @440 @45 @47) -> (hs : @1161 @111 @47 @49) -> @1161 @130 @1183 @1187 +@1234 := @1218 @2 +@1236 := @76 @45 @47 +@1238 := @1167 @47 @49 +@1246 := {v : @108} -> + {t : @110} -> {vs : @1170} -> {ts : @1171} -> (h : @1236) -> (hs : @1238) -> @1167 @1183 @1187 +@1247 := @1234 @1032 +@1248 := @897 @118 +@1250 := @76 @1248 @47 +@1251 := @897 @130 +@1252 := @1039 @1251 +@1260 := {t : @110} -> + {vs : @1170} -> {ts : @1171} -> (h : @1250) -> (hs : @1238) -> @1167 (@1252 @45) @1187 +@1261 := @1247 @906 +@1262 := @897 @45 +@1264 := @76 @1262 @906 +@1265 := @897 @111 +@1266 := @1039 @1265 +@1268 := @1167 (@1266 @45) +@1269 := @1185 @906 +@1270 := @1269 @47 +@1275 := {vs : @1170} -> {ts : @1171} -> (h : @1264) -> (hs : @1238) -> @1268 @1270 +@1276 := @1261 @1038 +@1277 := @897 @47 +@1279 := @76 @1277 @906 +@1280 := @1168 @49 +@1282 := @1039 @1248 @1038 +@1287 := {ts : @1171} -> (h : @1279) -> (hs : @1280) -> @1167 @1282 @1270 +@1288 := @1276 @1122 +@1290 := @1039 @1262 @1038 +@1291 := @1167 @1290 +@1292 := @1269 @1122 +@1295 := (h : @1035) -> (hs : @1169) -> @1291 @1292 +@1296 := @1288 @1033 +@1298 := @1039 @1277 @1038 +@1300 := @1167 @1298 @1292 +@1301 := (hs : @1169) -> @1300 +@1302 := @1296 @1166 +@1304 := @1167 @1041 @1292 +@1305 := @1234 @904 +@1306 := @903 @111 +@1308 := @76 @1306 @47 +@1309 := @903 @116 +@1310 := @1039 @1309 +@1318 := {t : @110} -> + {vs : @1170} -> {ts : @1171} -> (h : @1308) -> (hs : @1238) -> @1167 (@1310 @45) @1187 +@1319 := @1305 @909 +@1320 := @903 @118 +@1322 := @76 @1320 @909 +@1323 := @903 @130 +@1324 := @1039 @1323 +@1326 := @1167 (@1324 @45) +@1327 := @1185 @909 +@1328 := @1327 @47 +@1333 := {vs : @1170} -> {ts : @1171} -> (h : @1322) -> (hs : @1238) -> @1326 @1328 +@1334 := @1319 @1041 +@1335 := @903 @45 +@1337 := @76 @1335 @909 +@1338 := @1291 @49 +@1340 := @1039 @1306 @1282 +@1345 := {ts : @1171} -> (h : @1337) -> (hs : @1338) -> @1167 @1340 @1328 +@1346 := @1334 @1292 +@1348 := @1039 @1320 @1290 +@1349 := @1167 @1348 +@1350 := @1327 @1292 +@1353 := (h : @1031) -> (hs : @1300) -> @1349 @1350 +@1354 := @1346 @1029 +@1356 := @1039 @1335 @1298 +@1358 := @1167 @1356 @1350 +@1359 := (hs : @1304) -> @1358 +@1360 := @1354 @1302 +@1362 := @1167 @1043 @1350 +@1363 := @1234 @889 +@1364 := @754 @130 +@1366 := @76 @1364 @47 +@1367 := @754 @114 +@1368 := @1039 @1367 +@1376 := {t : @110} -> + {vs : @1170} -> {ts : @1171} -> (h : @1366) -> (hs : @1238) -> @1167 (@1368 @45) @1187 +@1377 := @1363 @762 +@1378 := @754 @111 +@1380 := @76 @1378 @762 +@1381 := @754 @116 +@1382 := @1039 @1381 +@1384 := @1167 (@1382 @45) +@1385 := @1185 @762 +@1386 := @1385 @47 +@1391 := {vs : @1170} -> {ts : @1171} -> (h : @1380) -> (hs : @1238) -> @1384 @1386 +@1392 := @1377 @1043 +@1393 := @754 @118 +@1395 := @76 @1393 @762 +@1396 := @1349 @49 +@1398 := @1039 @1364 @1340 +@1403 := {ts : @1171} -> (h : @1395) -> (hs : @1396) -> @1167 @1398 @1386 +@1404 := @1392 @1350 +@1406 := @1039 @1378 @1348 +@1407 := @1167 @1406 +@1408 := @1385 @1350 +@1411 := (h : @892) -> (hs : @1358) -> @1407 @1408 +@1412 := @1404 @890 +@1414 := @1039 @1393 @1356 +@1416 := @1167 @1414 @1408 +@1417 := (hs : @1362) -> @1416 +@1418 := @1412 @1360 +@1420 := @1167 @1045 @1408 +@1421 := @1234 @761 +@1422 := @760 @116 +@1424 := @76 @1422 @47 +@1425 := @760 @112 +@1426 := @1039 @1425 +@1434 := {t : @110} -> + {vs : @1170} -> {ts : @1171} -> (h : @1424) -> (hs : @1238) -> @1167 (@1426 @45) @1187 +@1435 := @1421 @765 +@1436 := @760 @130 +@1438 := @76 @1436 @765 +@1439 := @760 @114 +@1440 := @1039 @1439 +@1442 := @1167 (@1440 @45) +@1443 := @1185 @765 +@1444 := @1443 @47 +@1449 := {vs : @1170} -> {ts : @1171} -> (h : @1438) -> (hs : @1238) -> @1442 @1444 +@1450 := @1435 @1045 +@1451 := @760 @111 +@1453 := @76 @1451 @765 +@1454 := @1407 @49 +@1456 := @1039 @1422 @1398 +@1461 := {ts : @1171} -> (h : @1453) -> (hs : @1454) -> @1167 @1456 @1444 +@1462 := @1450 @1408 +@1464 := @1039 @1436 @1406 +@1465 := @1167 @1464 +@1466 := @1443 @1408 +@1469 := (h : @888) -> (hs : @1416) -> @1465 @1466 +@1470 := @1462 @886 +@1472 := @1039 @1451 @1414 +@1474 := @1167 @1472 @1466 +@1475 := (hs : @1420) -> @1474 +@1476 := @1470 @1418 +@1478 := @1167 @1047 @1466 +@1479 := @1234 @746 +@1480 := @21 @114 +@1482 := @76 @1480 @47 +@1483 := @21 @13 +@1484 := @1039 @1483 +@1492 := {t : @110} -> + {vs : @1170} -> {ts : @1171} -> (h : @1482) -> (hs : @1238) -> @1167 (@1484 @45) @1187 +@1493 := @1479 @35 +@1494 := @21 @116 +@1496 := @76 @1494 @35 +@1497 := @21 @112 +@1498 := @1039 @1497 +@1500 := @1167 (@1498 @45) +@1501 := @1185 @35 +@1502 := @1501 @47 +@1507 := {vs : @1170} -> {ts : @1171} -> (h : @1496) -> (hs : @1238) -> @1500 @1502 +@1508 := @1493 @1047 +@1509 := @21 @130 +@1511 := @76 @1509 @35 +@1512 := @1465 @49 +@1514 := @1039 @1480 @1456 +@1519 := {ts : @1171} -> (h : @1511) -> (hs : @1512) -> @1167 @1514 @1502 +@1520 := @1508 @1466 +@1522 := @1039 @1494 @1464 +@1523 := @1167 @1522 +@1524 := @1501 @1466 +@1527 := (h : @749) -> (hs : @1474) -> @1523 @1524 +@1528 := @1520 @747 +@1530 := @1039 @1509 @1472 +@1532 := @1167 @1530 @1524 +@1533 := (hs : @1478) -> @1532 +@1534 := @1528 @1476 +@1536 := @1167 @1049 @1524 +@1537 := @1234 @649 +@1538 := @648 @112 +@1540 := @76 @1538 @47 +@1541 := @648 @132 +@1542 := @1039 @1541 +@1550 := {t : @110} -> + {vs : @1170} -> {ts : @1171} -> (h : @1540) -> (hs : @1238) -> @1167 (@1542 @45) @1187 +@1551 := @1537 @652 +@1552 := @648 @114 +@1554 := @76 @1552 @652 +@1555 := @648 @13 +@1556 := @1039 @1555 +@1558 := @1167 (@1556 @45) +@1559 := @1185 @652 +@1560 := @1559 @47 +@1565 := {vs : @1170} -> {ts : @1171} -> (h : @1554) -> (hs : @1238) -> @1558 @1560 +@1566 := @1551 @1049 +@1567 := @648 @116 +@1569 := @76 @1567 @652 +@1570 := @1523 @49 +@1572 := @1039 @1538 @1514 +@1577 := {ts : @1171} -> (h : @1569) -> (hs : @1570) -> @1167 @1572 @1560 +@1578 := @1566 @1524 +@1580 := @1039 @1552 @1522 +@1581 := @1167 @1580 +@1582 := @1559 @1524 +@1585 := (h : @745) -> (hs : @1532) -> @1581 @1582 +@1586 := @1578 @743 +@1588 := @1039 @1567 @1530 +@1590 := @1167 @1588 @1582 +@1591 := (hs : @1536) -> @1590 +@1592 := @1586 @1534 +@1594 := @1167 @1051 @1582 +@1595 := @1234 @636 +@1596 := @500 @13 +@1598 := @76 @1596 @47 +@1599 := #12 +@1600 := @500 @1599 +@1601 := @1039 @1600 +@1609 := {t : @110} -> + {vs : @1170} -> {ts : @1171} -> (h : @1598) -> (hs : @1238) -> @1167 (@1601 @45) @1187 +@1610 := @1595 @510 +@1611 := @500 @112 +@1613 := @76 @1611 @510 +@1614 := @500 @132 +@1615 := @1039 @1614 +@1617 := @1167 (@1615 @45) +@1618 := @1185 @510 +@1619 := @1618 @47 +@1624 := {vs : @1170} -> {ts : @1171} -> (h : @1613) -> (hs : @1238) -> @1617 @1619 +@1625 := @1610 @1051 +@1626 := @500 @114 +@1628 := @76 @1626 @510 +@1629 := @1581 @49 +@1631 := @1039 @1596 @1572 +@1636 := {ts : @1171} -> (h : @1628) -> (hs : @1629) -> @1167 @1631 @1619 +@1637 := @1625 @1582 +@1639 := @1039 @1611 @1580 +@1640 := @1167 @1639 +@1641 := @1618 @1582 +@1644 := (h : @639) -> (hs : @1590) -> @1640 @1641 +@1645 := @1637 @637 +@1647 := @1039 @1626 @1588 +@1649 := @1167 @1647 @1641 +@1650 := (hs : @1594) -> @1649 +@1651 := @1645 @1592 +@1653 := @1167 @1053 @1641 +@1654 := @1234 @507 +@1655 := @506 @132 +@1657 := @76 @1655 @47 +@1658 := #13 +@1659 := @506 @1658 +@1660 := @1039 @1659 +@1668 := {t : @110} -> + {vs : @1170} -> {ts : @1171} -> (h : @1657) -> (hs : @1238) -> @1167 (@1660 @45) @1187 +@1669 := @1654 @513 +@1670 := @506 @13 +@1672 := @76 @1670 @513 +@1673 := @506 @1599 +@1674 := @1039 @1673 +@1676 := @1167 (@1674 @45) +@1677 := @1185 @513 +@1678 := @1677 @47 +@1683 := {vs : @1170} -> {ts : @1171} -> (h : @1672) -> (hs : @1238) -> @1676 @1678 +@1684 := @1669 @1053 +@1685 := @506 @112 +@1687 := @76 @1685 @513 +@1688 := @1640 @49 +@1690 := @1039 @1655 @1631 +@1695 := {ts : @1171} -> (h : @1687) -> (hs : @1688) -> @1167 @1690 @1678 +@1696 := @1684 @1641 +@1698 := @1039 @1670 @1639 +@1699 := @1167 @1698 +@1700 := @1677 @1641 +@1703 := (h : @635) -> (hs : @1649) -> @1699 @1700 +@1704 := @1696 @633 +@1706 := @1039 @1685 @1647 +@1708 := @1167 @1706 @1700 +@1709 := (hs : @1653) -> @1708 +@1710 := @1704 @1651 +@1712 := @1167 @1055 @1700 +@1713 := @1234 @492 +@1714 := @20 @1599 +@1716 := @76 @1714 @47 +@1717 := #14 +@1718 := @20 @1717 +@1719 := @1039 @1718 +@1727 := {t : @110} -> + {vs : @1170} -> {ts : @1171} -> (h : @1716) -> (hs : @1238) -> @1167 (@1719 @45) @1187 +@1728 := @1713 @34 +@1729 := @20 @132 +@1731 := @76 @1729 @34 +@1732 := @20 @1658 +@1733 := @1039 @1732 +@1735 := @1167 (@1733 @45) +@1736 := @1185 @34 +@1737 := @1736 @47 +@1742 := {vs : @1170} -> {ts : @1171} -> (h : @1731) -> (hs : @1238) -> @1735 @1737 +@1743 := @1728 @1055 +@1744 := @20 @13 +@1746 := @76 @1744 @34 +@1747 := @1699 @49 +@1749 := @1039 @1714 @1690 +@1754 := {ts : @1171} -> (h : @1746) -> (hs : @1747) -> @1167 @1749 @1737 +@1755 := @1743 @1700 +@1757 := @1039 @1729 @1698 +@1758 := @1167 @1757 +@1759 := @1736 @1700 +@1762 := (h : @495) -> (hs : @1708) -> @1758 @1759 +@1763 := @1755 @493 +@1765 := @1039 @1744 @1706 +@1767 := @1167 @1765 @1759 +@1768 := (hs : @1712) -> @1767 +@1769 := @1763 @1710 +@1771 := @1167 @1057 @1759 +@1772 := @1234 @29 +@1773 := @28 @1658 +@1775 := @76 @1773 @47 +@1776 := #15 +@1777 := @28 @1776 +@1778 := @1039 @1777 +@1786 := {t : @110} -> + {vs : @1170} -> {ts : @1171} -> (h : @1775) -> (hs : @1238) -> @1167 (@1778 @45) @1187 +@1787 := @1772 @39 +@1788 := @28 @1599 +@1790 := @76 @1788 @39 +@1791 := @28 @1717 +@1792 := @1039 @1791 +@1794 := @1167 (@1792 @45) +@1795 := @1185 @39 +@1796 := @1795 @47 +@1801 := {vs : @1170} -> {ts : @1171} -> (h : @1790) -> (hs : @1238) -> @1794 @1796 +@1802 := @1787 @1057 +@1803 := @28 @132 +@1805 := @76 @1803 @39 +@1806 := @1758 @49 +@1808 := @1039 @1773 @1749 +@1809 := @1167 @1808 +@1813 := {ts : @1171} -> (h : @1805) -> (hs : @1806) -> @1809 @1796 +@1814 := @1802 @1759 +@1816 := @1039 @1788 @1757 +@1817 := @1167 @1816 +@1818 := @1795 @1759 +@1821 := (h : @491) -> (hs : @1767) -> @1817 @1818 +@1822 := @1814 @489 +@1824 := @1039 @1803 @1765 +@1825 := @1167 @1824 +@1827 := (hs : @1771) -> @1825 @1818 +@1828 := @1822 @1769 +@1829 := @1167 @1059 +@1830 := @1829 @1818 +@1831 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.denoteEntry +@1841 := @1831 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49 +@1842 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.entryFits +@1852 := @1842 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49 +@1863 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.entryValue + @13 + @112 + @114 + @116 + @130 + @111 + @118 + @45 + @47 + @49 +@1874 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.entry + @13 + @112 + @114 + @116 + @130 + @111 + @118 + @45 + @47 + @49 +@1875 := Ne.{1} +@1876 := LexLeanPreservation.Obs +@1877 := @1875 @1876 +@1878 := LexLeanPreservation.Rel +@1881 := @1877 (@1878 @49 @40) +@1882 := LexLeanPreservation.Obs.stuck +@1885 := (f : @8) -> (v : @108) -> @1881 @1882 +@1887 := LexLeanPreservation.Rust.rel_ne_stuck @1852 +@1902 := (v : @108) -> + @1877 (@1878 (@1842 @132 @13 @112 @114 @116 @130 @111 @118 @45 @47) @40) @1882 +@1903 := @1887 @1863 +@1907 := @1877 (@1878 @1852 @1863) @1882 +@1908 := @11 @1060 +@1909 := LexLeanPreservation.Rust.FunSem +@1915 := (n : @3) -> @1909 @112 @114 @116 @40 @130 +@1916 := Eq.{1} +@1917 := Option.{0} +@1918 := @1917 @1117 +@1919 := @1916 @1918 +@1926 := LexLeanRuntime.index (@11 @1117) @1117 (LexLeanRuntime.instIndexableList @1117) +@1930 := @1919 (@1926 (@1118 @112) @130) +@1931 := Option.some.{0} +@1932 := @1931 @1117 +@1933 := @1932 @111 +@1934 := @1930 @1933 +@1938 := @1142 @13 @112 @114 @111 +@1939 := LexLeanTarget.TargetSyntax.Function.types +@1940 := @1939 @130 +@1941 := @1938 @1940 +@1942 := @1917 @1908 +@1943 := @1916 @1942 +@1944 := LexLeanTarget.TargetSemantics.bindAll +@1945 := LexLeanTarget.TargetSyntax.Function.parameters +@1950 := @1943 (@1944 (@1945 @116) @130 @1094) +@1951 := @1931 @1908 +@1952 := @1951 @111 +@1953 := @1950 @1952 +@1954 := @1917 @8 +@1955 := @1916 @1954 +@1956 := LexLeanPreservation.Rust.fnFallible +@1959 := @1955 (@1956 @132 @112) +@1960 := @1931 @8 +@1961 := @1960 @111 +@1962 := @1959 @1961 +@1963 := LexLeanPreservation.RunConv +@1967 := @1963 @1658 @13 @114 @111 +@1969 := @1877 @130 @1882 +@1970 := Exists.{1} +@1971 := LexLeanPreservation.Rust.ROut +@1972 := @1970 @1971 +@1973 := And +@1974 := LexLeanPreservation.Rust.RealizesFn +@1978 := @1973 (@1974 @112 @114 @40) +@1979 := LexLeanPreservation.Rust.RCI +@1980 := @1979 @1776 +@1981 := LexLeanPreservation.Rust.fnIdent +@1982 := @1981 @1658 +@1989 := (hne : @1969) -> @1972 (fun (ro : @1971) => @1978 (@1980 @1982 @132 @40)) +@2004 := {p : @41} -> + {c : @42} -> + {A : @43} -> + {f : @3} -> + {fn : @1117} -> + {args : @1170} -> + {env : @1908} -> + {F : @8} -> + {o : @1876} -> + (hB : @1915) -> + (hfn : @1934) -> (hwt : @1941) -> (hbind : @1953) -> (hF : @1962) -> (hA : @1967) -> @1989 +@2006 := LexLeanPreservation.Rust.compose @0 +@2007 := @1909 @0 +@2012 := (n : @3) -> @2007 @114 @116 @40 @130 +@2013 := @1926 @1119 +@2016 := @1919 (@2013 @130) @1933 +@2020 := @1153 @112 @114 @111 @1940 +@2021 := @1963 @0 +@2024 := @2021 @13 @114 @111 +@2038 := {c : @42} -> + {A : @43} -> + {f : @3} -> + {fn : @1117} -> + {args : @1170} -> + {env : @1908} -> + {F : @8} -> + {o : @1876} -> + (hB : @2012) -> + (hfn : @2016) -> (hwt : @2020) -> (hbind : @1953) -> (hF : @1962) -> (hA : @2024) -> @1989 +@2039 := @2006 @1 +@2040 := @2007 @1 +@2044 := (n : @3) -> @2040 @116 @40 @130 +@2047 := @1161 @114 @111 @1940 +@2048 := @1956 @1 +@2051 := @1955 (@2048 @112) @1961 +@2052 := @1979 @1 +@2062 := (hbind : @1953) -> + (hF : @2051) -> + (hA : @2024) -> (hne : @1969) -> @1972 (fun (ro : @1971) => @1978 (@2052 @1982 @132 @40)) +@2072 := {A : @43} -> + {f : @3} -> + {fn : @1117} -> + {args : @1170} -> + {env : @1908} -> + {F : @8} -> {o : @1876} -> (hB : @2044) -> (hfn : @2016) -> (hwt : @2047) -> @2062 +@2073 := @2039 @2 +@2075 := @2040 @2 @40 +@2077 := (n : @3) -> @2075 @130 +@2078 := @1167 @111 +@2079 := @2078 @1940 +@2088 := {f : @3} -> + {fn : @1117} -> + {args : @1170} -> + {env : @1908} -> + {F : @8} -> {o : @1876} -> (hB : @2077) -> (hfn : @2016) -> (hwt : @2079) -> @2062 +@2089 := @2073 @1120 +@2091 := (n : @3) -> @2075 @1120 +@2092 := @2013 @1120 +@2093 := @1919 @2092 +@2094 := @2093 @1933 +@2095 := @2048 @1120 +@2096 := @1955 @2095 +@2097 := @2096 @1961 +@2098 := @2021 @1120 +@2100 := @2098 @114 @111 +@2102 := @2052 (@1981 @1120) +@2110 := (hF : @2097) -> + (hA : @2100) -> (hne : @1969) -> @1972 (fun (ro : @1971) => @1978 (@2102 @132 @40)) +@2119 := {fn : @1117} -> + {args : @1170} -> + {env : @1908} -> + {F : @8} -> + {o : @1876} -> (hB : @2091) -> (hfn : @2094) -> (hwt : @2079) -> (hbind : @1953) -> @2110 +@2120 := @2089 @1137 +@2122 := @2093 (@1932 @1137) +@2123 := @1939 @1137 +@2124 := @2078 @2123 +@2126 := @1944 (@1945 @1137) +@2138 := {args : @1170} -> + {env : @1908} -> + {F : @8} -> + {o : @1876} -> + (hB : @2091) -> + (hfn : @2122) -> (hwt : @2124) -> (hbind : @1943 (@2126 @130 @1094) @1952) -> @2110 +@2139 := @2120 @1059 +@2149 := @1778 (@1719 (@1660 (@1601 (@1542 (@1484 (@1426 (@1368 (@1310 (@1252 @1038))))))))) +@2151 := @1167 @2149 @2123 +@2152 := #16 +@2182 := @1039 + (@28 @2152) + (@1039 + (@20 @1776) + (@1039 + (@506 @1717) + (@1039 + (@500 @1658) + (@1039 + (@648 @1599) + (@1039 + (@21 @132) + (@1039 + (@760 @13) + (@1039 (@754 @112) (@1039 (@903 @114) (@1039 (@897 @116) @1038))))))))) +@2186 := @1943 (@2126 @2182 @1094) @1952 +@2187 := #18 +@2189 := @1039 (@28 @2187) +@2190 := #17 +@2218 := @2189 + (@1039 + (@20 @2190) + (@1039 + (@506 @2152) + (@1039 + (@500 @1776) + (@1039 + (@648 @1717) + (@1039 + (@21 @1658) + (@1039 + (@760 @1599) + (@1039 (@754 @132) (@1039 (@903 @13) (@1039 (@897 @112) @1038))))))))) +@2220 := @2098 @2218 @111 +@2223 := @1039 (@28 #21) +@2224 := #20 +@2226 := @1039 (@20 @2224) +@2227 := #19 +@2268 := {env : @1908} -> + {F : @8} -> + {o : @1876} -> + (hB : @2091) -> + (hfn : @2122) -> + (hwt : @2151) -> + (hbind : @2186) -> + (hF : @2097) -> + (hA : @2220) -> + (hne : @1969) -> + @1972 + (fun (ro : @1971) => + @1978 + (@2102 + (@2223 + (@2226 + (@1039 + (@506 @2227) + (@1039 + (@500 @2187) + (@1039 + (@648 @2190) + (@1039 + (@21 @2152) + (@1039 + (@760 @1776) + (@1039 (@754 @1717) (@1039 (@903 @1658) (@1039 (@897 @1599) @1038)))))))))) + @40)) +@2269 := @2139 @1115 +@2279 := @1792 (@1733 (@1674 (@1615 (@1556 (@1498 (@1440 (@1382 (@1324 (@1266 @1038))))))))) +@2281 := @1167 @2279 @2123 +@2316 := @1943 + (@2126 @2149 @1094) + (@1951 + (@1095 + (@1065 @1251) + (@1095 + (@1068 @1309) + (@1095 + (@1071 @1367) + (@1095 + (@1074 @1425) + (@1095 + (@1077 @1483) + (@1095 + (@1080 @1541) + (@1095 + (@1083 @1600) + (@1095 (@1086 @1659) (@1095 (@1089 @1718) (@1095 (@1092 @1777) @1094))))))))))) +@2346 := @1039 + (@28 @2190) + (@1039 + (@20 @2152) + (@1039 + (@506 @1776) + (@1039 + (@500 @1717) + (@1039 + (@648 @1658) + (@1039 + (@21 @1599) + (@1039 + (@760 @132) + (@1039 (@754 @13) (@1039 (@903 @112) (@1039 (@897 @114) @1038))))))))) +@2392 := {F : @8} -> + {o : @1876} -> + (hB : @2091) -> + (hfn : @2122) -> + (hwt : @2281) -> + (hbind : @2316) -> + (hF : @2097) -> + (hA : @2098 @2346 @111) -> + (hne : @1969) -> + @1972 + (fun (ro : @1971) => + @1978 + (@2102 + (@1039 + (@28 @2224) + (@1039 + (@20 @2227) + (@1039 + (@506 @2187) + (@1039 + (@500 @2190) + (@1039 + (@648 @2152) + (@1039 + (@21 @1776) + (@1039 + (@760 @1717) + (@1039 (@754 @1658) (@1039 (@903 @1599) (@1039 (@897 @132) @1038)))))))))) + @40)) +@2393 := @2269 @1116 +@2394 := @1809 @2123 +@2429 := @1943 + (@2126 @2279 @1094) + (@1951 + (@1095 + (@1065 @1265) + (@1095 + (@1068 @1323) + (@1095 + (@1071 @1381) + (@1095 + (@1074 @1439) + (@1095 + (@1077 @1497) + (@1095 + (@1080 @1555) + (@1095 + (@1083 @1614) + (@1095 (@1086 @1673) (@1095 (@1089 @1732) (@1095 (@1092 @1791) @1094))))))))))) +@2431 := @2096 (@1960 @1116) +@2433 := @2098 @2182 @111 +@2434 := @1974 @1116 +@2480 := {o : @1876} -> + (hB : @2091) -> + (hfn : @2122) -> + (hwt : @2394) -> + (hbind : @2429) -> + (hF : @2431) -> + (hA : @2433) -> + (hne : @1969) -> + @1972 + (fun (ro : @1971) => + @1973 + (@2434 @114 @40) + (@2102 + (@1039 + (@28 @2227) + (@1039 + (@20 @2187) + (@1039 + (@506 @2190) + (@1039 + (@500 @2152) + (@1039 + (@648 @1776) + (@1039 + (@21 @1717) + (@1039 + (@760 @1658) + (@1039 (@754 @1599) (@1039 (@903 @132) (@1039 (@897 @13) @1038)))))))))) + @40)) +@2481 := @2393 @1841 +@2482 := @1817 @2123 +@2517 := @1943 + (@2126 @1808 @1094) + (@1951 + (@1095 + (@1065 @1248) + (@1095 + (@1068 @1306) + (@1095 + (@1071 @1364) + (@1095 + (@1074 @1422) + (@1095 + (@1077 @1480) + (@1095 + (@1080 @1538) + (@1095 + (@1083 @1596) + (@1095 (@1086 @1655) (@1095 (@1089 @1714) (@1095 (@1092 @1773) @1094))))))))))) +@2518 := @2098 @2149 +@2528 := @1831 @1776 @1717 @1658 @1599 @132 @13 @112 @114 @116 @130 +@2529 := @2518 @2528 +@2539 := @1831 @2152 @1776 @1717 @1658 @1599 @132 @13 @112 @114 @116 +@2566 := (hB : @2091) -> + (hfn : @2122) -> + (hwt : @2482) -> + (hbind : @2517) -> + (hF : @2431) -> + (hA : @2529) -> + (hne : @1877 @2539 @1882) -> + @1972 + (fun (ro : @1971) => + @1973 + (@2434 (@1831 @2187 @2190 @2152 @1776 @1717 @1658 @1599 @132 @13 @112) @40) + (@2102 @2218 @40)) +@2567 := @2481 @1141 +@2568 := @1825 @2123 +@2603 := @1943 + (@2126 @1816 @1094) + (@1951 + (@1095 + (@1065 @1262) + (@1095 + (@1068 @1320) + (@1095 + (@1071 @1378) + (@1095 + (@1074 @1436) + (@1095 + (@1077 @1494) + (@1095 + (@1080 @1552) + (@1095 + (@1083 @1611) + (@1095 (@1086 @1670) (@1095 (@1089 @1729) (@1095 (@1092 @1788) @1094))))))))))) +@2604 := @2098 @2279 +@2614 := @1831 @1717 @1658 @1599 @132 @13 @112 @114 @116 @130 @111 +@2641 := (hfn : @2122) -> + (hwt : @2568) -> + (hbind : @2603) -> + (hF : @2431) -> + (hA : @2604 @2614) -> + (hne : @1877 @2528 @1882) -> + @1972 + (fun (ro : @1971) => + @1973 + (@2434 (@1831 @2190 @2152 @1776 @1717 @1658 @1599 @132 @13 @112 @114) @40) + (@2102 @2346 @40)) +@2642 := Eq.refl.{1} +@2645 := @2567 (@2642 @1918 @2092) +@2646 := @1829 @2123 +@2681 := @1943 + (@2126 @1824 @1094) + (@1951 + (@1095 + (@1065 @1277) + (@1095 + (@1068 @1335) + (@1095 + (@1071 @1393) + (@1095 + (@1074 @1451) + (@1095 + (@1077 @1509) + (@1095 + (@1080 @1567) + (@1095 + (@1083 @1626) + (@1095 (@1086 @1685) (@1095 (@1089 @1744) (@1095 (@1092 @1803) @1094))))))))))) +@2682 := @2098 @1808 +@2692 := @1831 @1658 @1599 @132 @13 @112 @114 @116 @130 @111 @118 +@2708 := (hwt : @2646) -> + (hbind : @2681) -> + (hF : @2431) -> + (hA : @2682 @2692) -> + (hne : @1877 @2614 @1882) -> @1972 (fun (ro : @1971) => @1973 (@2434 @2539 @40) (@2102 @2182 @40)) +@2709 := @2645 @1828 +@2711 := @2126 @1059 @1094 +@2714 := @1943 @2711 (@1951 @1115) +@2715 := @2098 @1816 +@2725 := @1831 @1599 @132 @13 @112 @114 @116 @130 @111 @118 @45 +@2740 := (hbind : @2714) -> + (hF : @2431) -> + (hA : @2715 @2725) -> + (hne : @1877 @2692 @1882) -> @1972 (fun (ro : @1971) => @1973 (@2434 @2528 @40) (@2102 @2149 @40)) +@2743 := @2709 (@2642 @1942 @2711) +@2744 := @2098 @1824 +@2754 := @1831 @132 @13 @112 @114 @116 @130 @111 @118 @45 @47 +@2768 := (hF : @2431) -> + (hA : @2744 @2754) -> + (hne : @1877 @2725 @1882) -> @1972 (fun (ro : @1971) => @1973 (@2434 @2614 @40) (@2102 @2279 @40)) +@2771 := @2743 (@2642 @1954 @2095) +@2773 := @2098 @1059 @1841 +@2775 := @1877 @2754 @1882 +@2776 := @2434 @2692 +@2778 := @1973 (@2776 @40) +@2779 := @2102 @1808 +@2780 := @2779 @40 +@2785 := (hA : @2773) -> (hne : @2775) -> @1972 (fun (ro : @1971) => @2778 @2780) +@2786 := @2771 @1874 +@2788 := @1877 @1841 @1882 +@2789 := @2434 @2725 +@2791 := @1973 (@2789 @40) +@2792 := @2102 @1816 +@2797 := (hne : @2788) -> @1972 (fun (ro : @1971) => @2791 (@2792 @40)) +@2798 := @2786 @1903 +@2801 := @1973 (@2434 @2754 @40) +@2803 := @2102 @1824 @40 +@2804 := @2801 @2803 +@2806 := @1972 (fun (ro : @1971) => @2804) +@2807 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.accepts +@2817 := @2807 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49 +@2818 := LexLeanPreservation.someObs +@2819 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.denote +@2830 := @2818 (@2819 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49) +@2833 := LexLeanPreservation.Obs.value LexLeanTarget.TargetSyntax.Value.none +@2834 := Not +@2835 := @2834 @2817 +@2845 := @2807 @132 @13 @112 @114 @116 @130 @111 @118 @45 @47 +@2856 := @2818 (@2819 @132 @13 @112 @114 @116 @130 @111 @118 @45 @47) +@2857 := @2834 @2845 +@2871 := @2845 -> @2434 (@2818 (@2819 @1599 @132 @13 @112 @114 @116 @130 @111 @118 @45)) @49 +@2872 := @2434 @2833 +@2873 := @2872 @49 +@2874 := @2857 -> @2873 +@2876 := @1973 @2871 @2874 +@2880 := @1972 (fun (__e_ro : @1971) => @1973 @2803 @2876) +@2881 := fun (__e_ro : @1971) => @2804 +@2882 := @2789 @49 +@2883 := @2792 @49 +@2884 := And.left +@2885 := And.right +@2888 := @2884 @2882 @2883 @40 +@2891 := @2885 @2882 @2883 @40 +@2892 := @2434 @40 +@2894 := fun (__e_o : @1876) => @2892 @47 +@2895 := Eq.subst.{1} +@2905 := @2807 @1599 @132 @13 @112 @114 @116 @130 @111 @118 @45 +@2906 := @2834 @2905 +@2918 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.entry_accepts + @1658 + @1599 + @132 + @13 + @112 + @114 + @116 + @130 + @111 + @118 + @40 +@2929 := @2818 (@2819 @1658 @1599 @132 @13 @112 @114 @116 @130 @111 @118) +@2934 := @2884 (@2776 @47) (@2779 @47) @49 +@2936 := fun (__e_o : @1876) => @2892 @45 +@2939 := @2895 @1876 @2936 @2692 +@2943 := fun (__e_h : @2905) => @2939 @2929 @2918 @2934 +@2955 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.entry_refuses + @1658 + @1599 + @132 + @13 + @112 + @114 + @116 + @130 + @111 + @118 + @40 +@2959 := fun (__e_h : @2906) => @2939 @2833 @2955 @2934 +@2960 := And.intro +@2963 := @2905 -> @2434 @2929 @47 +@2965 := @2906 -> @2872 @47 +@2967 := @1973 @2963 @2965 +@2971 := @2960 @2963 @2965 @2943 @2959 +@2975 := @2960 @2883 @2967 @2891 @2971 +@2976 := Exists.intro.{1} +@2977 := @1973 @2780 +@2987 := @2807 @1658 @1599 @132 @13 @112 @114 @116 @130 @111 @118 +@3007 := fun (__e_ro : @1971) => + @2977 + (@1973 + (@2987 -> @2434 (@2818 (@2819 @1717 @1658 @1599 @132 @13 @112 @114 @116 @130 @111)) @49) + (@2834 @2987 -> @2873)) +@3011 := @2976 @1971 @3007 @49 @2975 +@3013 := @1973 @2882 @2883 +@3015 := fun (__e_ro : @1971) => fun (__e_hand : @2804) => @3011 +@3021 := Exists.elim.{1} @1971 @2881 @2880 @2798 @3015 +@3022 := LexLeanPreservation.Rust.RepresentableL +@3023 := @28 @112 +@3024 := @20 @114 +@3025 := @506 @116 +@3026 := @500 @130 +@3027 := @648 @111 +@3028 := @21 @118 +@3029 := @760 @45 +@3030 := @754 @47 +@3031 := @903 @49 +@3033 := @1039 @910 @1038 +@3035 := @1039 @3031 @3033 +@3037 := @1039 @3030 @3035 +@3039 := @1039 @3029 @3037 +@3041 := @1039 @3028 @3039 +@3043 := @1039 @3027 @3041 +@3045 := @1039 @3026 @3043 +@3047 := @1039 @3025 @3045 +@3049 := @1039 @3024 @3047 +@3052 := @3022 (@1039 @3023 @3049) +@3053 := (__e_hrep : @3052) -> @2880 +@3054 := fun (__e_hrep : @3052) => @3021 +@3055 := (w : @893) -> @3053 +@3056 := fun (w : @893) => @3054 +@3057 := (u : @896) -> @3055 +@3058 := fun (u : @896) => @3056 +@3059 := (e : @750) -> @3057 +@3060 := fun (e : @750) => @3058 +@3061 := (d : @753) -> @3059 +@3062 := fun (d : @753) => @3060 +@3063 := (c : @8) -> @3061 +@3064 := fun (c : @8) => @3062 +@3065 := (b : @642) -> @3063 +@3066 := fun (b : @642) => @3064 +@3067 := (j : @496) -> @3065 +@3068 := fun (j : @496) => @3066 +@3069 := (i : @499) -> @3067 +@3070 := fun (i : @499) => @3068 +@3071 := (k : @7) -> @3069 +@3072 := fun (k : @7) => @3070 +@3073 := (a : @12) -> @3071 +@3074 := fun (a : @12) => @3072 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R9/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R9/Compose/RustStd.lean deleted file mode 100644 index 24411d770..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R9/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9 -import LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (x : Nat) (s : String) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat x), (_root_.LexLeanTarget.TargetSyntax.Value.string s)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.denote x s) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat x), (_root_.LexLeanTarget.TargetSyntax.Value.string s)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat x) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_string s) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.root x s) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R9/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R9/Compose/RustStd.lex.tex new file mode 100644 index 000000000..5302ce971 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R9/Compose/RustStd.lex.tex @@ -0,0 +1,501 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9, + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd.root : @1005 := @1006 { + all: [LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd.program +@1 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd.krate +@2 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd.flags +@3 := Nat +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@29 := @27 @4 @15 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @29 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@37 := @36 @15 +@41 := {A : @10} -> (n : @3) -> @37 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := String +@51 := LexLeanTarget.TargetSyntax.Value.string +@52 := @51 @15 +@53 := LexLeanTarget.TargetSyntax.Ty.string +@54 := @51 @17 +@60 := {p : @8} -> {c : @9} -> {A : @10} -> (s : @50) -> @16 @54 @53 +@62 := LexLeanPreservation.Rust.wt_string @0 +@67 := {c : @9} -> {A : @10} -> (s : @50) -> @29 @54 @53 +@68 := @62 @1 +@72 := {A : @10} -> (s : @50) -> @37 @54 @53 +@73 := @68 @2 +@76 := (s : @50) -> @43 @54 @53 +@77 := @73 @15 +@79 := @43 @52 @53 +@80 := LexLeanTarget.TargetSyntax.Value +@81 := List.nil.{0} +@82 := List.cons.{0} +@83 := @81 @80 +@84 := @82 @80 +@86 := @84 @52 @83 +@88 := @84 @6 @86 +@89 := Prod.{0, 0} +@90 := @89 @3 +@91 := @90 @80 +@92 := 1 +@95 := Prod.mk.{0, 0} @3 @80 +@96 := @95 @92 +@97 := @96 @52 +@98 := 0 +@99 := @95 @98 +@100 := @99 @6 +@101 := @81 @91 +@102 := @82 @91 +@104 := @102 @100 @101 +@106 := @102 @97 @104 +@107 := Bool.false +@108 := LexLeanTarget.TargetSyntax.Function +@109 := LexLeanTarget.TargetSyntax.Program.functions +@110 := @109 @0 +@111 := LexLeanTarget.TargetSyntax.Ty +@112 := @81 @3 +@113 := @81 @111 +@114 := LexLeanTarget.TargetSyntax.Ty.unit +@115 := LexLeanTarget.TargetSyntax.Value.unit +@118 := LexLeanTarget.TargetSyntax.Expr.value @114 @115 +@123 := LexLeanTarget.TargetSyntax.Function.mk @112 @113 @114 @118 +@128 := List.getD.{0} @108 @110 @98 @123 +@132 := fun (__e_n : @3) => + LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd.root @17 @98 +@133 := LexLeanPreservation.Rust.WTL +@141 := {p : @8} -> {c : @9} -> {A : @10} -> @133 @4 @15 @17 @83 @113 +@143 := LexLeanPreservation.Rust.wtl_nil @0 +@144 := @133 @0 +@150 := {c : @9} -> {A : @10} -> @144 @15 @17 @83 @113 +@151 := @143 @1 +@152 := @144 @1 +@156 := {A : @10} -> @152 @17 @83 @113 +@157 := @151 @2 +@158 := @152 @2 +@159 := @158 @83 +@160 := @159 @113 +@161 := List.{0} +@162 := @161 @80 +@163 := @161 @111 +@164 := #6 +@165 := @11 @164 +@166 := #5 +@167 := @165 @166 +@168 := #4 +@171 := @167 @168 @12 @4 +@172 := #7 +@177 := @133 @172 @164 @166 @4 @15 +@178 := #8 +@181 := @133 @178 @172 @164 +@183 := @84 @166 @12 +@184 := @181 @183 +@185 := @82 @111 +@187 := @185 @168 @4 +@197 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @80} -> {t : @111} -> {vs : @162} -> {ts : @163} -> (h : @171) -> (hs : @177) -> @184 @187 +@199 := LexLeanPreservation.Rust.wtl_cons @0 +@219 := {c : @9} -> + {A : @10} -> + {v : @80} -> + {t : @111} -> + {vs : @162} -> + {ts : @163} -> + (h : @27 @166 @168 @12 @4) -> (hs : @144 @164 @166 @4 @15) -> @144 @172 @164 @183 @187 +@220 := @199 @1 +@236 := {A : @10} -> + {v : @80} -> + {t : @111} -> + {vs : @162} -> + {ts : @163} -> (h : @36 @168 @12 @4) -> (hs : @152 @166 @4 @15) -> @152 @164 @183 @187 +@237 := @220 @2 +@239 := @43 @12 @4 +@241 := @158 @4 @15 +@249 := {v : @80} -> + {t : @111} -> {vs : @162} -> {ts : @163} -> (h : @239) -> (hs : @241) -> @158 @183 @187 +@250 := @237 @52 +@251 := @51 @168 +@253 := @43 @251 @4 +@254 := @51 @164 +@255 := @84 @254 +@263 := {t : @111} -> + {vs : @162} -> {ts : @163} -> (h : @253) -> (hs : @241) -> @158 (@255 @12) @187 +@264 := @250 @53 +@265 := @51 @12 +@267 := @43 @265 @53 +@268 := @51 @166 +@269 := @84 @268 +@271 := @158 (@269 @12) +@272 := @185 @53 +@273 := @272 @4 +@278 := {vs : @162} -> {ts : @163} -> (h : @267) -> (hs : @241) -> @271 @273 +@279 := @264 @83 +@280 := @51 @4 +@282 := @43 @280 @53 +@283 := @159 @15 +@285 := @84 @251 @83 +@290 := {ts : @163} -> (h : @282) -> (hs : @283) -> @158 @285 @273 +@291 := @279 @113 +@293 := @84 @265 @83 +@294 := @158 @293 +@295 := @272 @113 +@298 := (h : @79) -> (hs : @160) -> @294 @295 +@299 := @291 @77 +@301 := @84 @280 @83 +@303 := @158 @301 @295 +@304 := (hs : @160) -> @303 +@305 := @299 @157 +@307 := @158 @86 @295 +@308 := @237 @6 +@309 := @5 @166 +@311 := @43 @309 @4 +@312 := @5 @172 +@313 := @84 @312 +@321 := {t : @111} -> + {vs : @162} -> {ts : @163} -> (h : @311) -> (hs : @241) -> @158 (@313 @12) @187 +@322 := @308 @7 +@323 := @5 @168 +@325 := @43 @323 @7 +@326 := @5 @164 +@327 := @84 @326 +@329 := @158 (@327 @12) +@330 := @185 @7 +@331 := @330 @4 +@336 := {vs : @162} -> {ts : @163} -> (h : @325) -> (hs : @241) -> @329 @331 +@337 := @322 @86 +@338 := @5 @12 +@340 := @43 @338 @7 +@341 := @294 @15 +@343 := @84 @309 @285 +@344 := @158 @343 +@348 := {ts : @163} -> (h : @340) -> (hs : @341) -> @344 @331 +@349 := @337 @295 +@351 := @84 @323 @293 +@352 := @158 @351 +@353 := @330 @295 +@356 := (h : @49) -> (hs : @303) -> @352 @353 +@357 := @349 @47 +@359 := @84 @338 @301 +@360 := @158 @359 +@362 := (hs : @307) -> @360 @353 +@363 := @357 @305 +@364 := @158 @88 +@365 := @364 @353 +@366 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.denote +@368 := @366 @4 @15 +@369 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.__fits_0 +@371 := @369 @4 @15 +@374 := Coverage.Colls.literals @4 @15 +@376 := @89 @50 @3 +@377 := @161 @376 +@378 := @161 @3 +@379 := @90 @378 +@380 := @161 @379 +@382 := @89 @378 @380 +@383 := LexLeanPreservation.encPair +@387 := @383 @50 @3 @51 @5 +@388 := LexLeanPreservation.encList +@390 := @388 @376 @387 +@392 := @388 @3 @5 +@396 := @383 @3 @378 @5 @392 +@398 := @388 @379 @396 +@402 := @383 @378 @380 @392 @398 +@407 := @383 @377 @382 @390 @402 @374 +@410 := LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.root @4 @15 +@411 := Bool +@412 := Ne.{1} +@413 := LexLeanPreservation.Obs +@414 := @412 @413 +@415 := LexLeanPreservation.Rel +@418 := @414 (@415 @15 @17) +@419 := LexLeanPreservation.Obs.stuck +@422 := (f : @411) -> (v : @80) -> @418 @419 +@424 := LexLeanPreservation.Rust.rel_ne_stuck @371 +@431 := (v : @80) -> @414 (@415 (@369 @12 @4) @17) @419 +@432 := @424 @407 +@436 := @414 (@415 @371 @407) @419 +@437 := @161 @91 +@438 := LexLeanPreservation.Rust.FunSem +@439 := #9 +@445 := (n : @3) -> @438 @439 @178 @172 @17 @164 +@446 := Eq.{1} +@447 := Option.{0} +@448 := @447 @108 +@449 := @446 @448 +@456 := LexLeanRuntime.index (@161 @108) @108 (LexLeanRuntime.instIndexableList @108) +@460 := @449 (@456 (@109 @439) @164) +@461 := Option.some.{0} +@462 := @461 @108 +@463 := @462 @166 +@464 := @460 @463 +@465 := #10 +@469 := @133 @465 @439 @178 @166 +@470 := LexLeanTarget.TargetSyntax.Function.types +@471 := @470 @164 +@472 := @469 @471 +@473 := @447 @437 +@474 := @446 @473 +@475 := LexLeanTarget.TargetSemantics.bindAll +@476 := LexLeanTarget.TargetSyntax.Function.parameters +@481 := @474 (@475 (@476 @172) @164 @101) +@482 := @461 @437 +@483 := @482 @166 +@484 := @481 @483 +@485 := @447 @411 +@486 := @446 @485 +@487 := LexLeanPreservation.Rust.fnFallible +@488 := #11 +@491 := @486 (@487 @488 @439) +@492 := @461 @411 +@493 := @492 @166 +@494 := @491 @493 +@495 := LexLeanPreservation.RunConv +@496 := #13 +@500 := @495 @496 @465 @178 @166 +@502 := @414 @164 @419 +@503 := Exists.{1} +@504 := LexLeanPreservation.Rust.ROut +@505 := @503 @504 +@506 := And +@507 := LexLeanPreservation.Rust.RealizesFn +@511 := @506 (@507 @439 @178 @17) +@512 := LexLeanPreservation.Rust.RCI +@514 := @512 #15 +@515 := LexLeanPreservation.Rust.fnIdent +@516 := @515 @496 +@523 := (hne : @502) -> @505 (fun (ro : @504) => @511 (@514 @516 @488 @17)) +@538 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @108} -> + {args : @162} -> + {env : @437} -> + {F : @411} -> + {o : @413} -> + (hB : @445) -> + (hfn : @464) -> (hwt : @472) -> (hbind : @484) -> (hF : @494) -> (hA : @500) -> @523 +@540 := LexLeanPreservation.Rust.compose @0 +@541 := @438 @0 +@546 := (n : @3) -> @541 @178 @172 @17 @164 +@547 := @456 @110 +@550 := @449 (@547 @164) @463 +@554 := @144 @439 @178 @166 @471 +@555 := @495 @0 +@558 := @555 @465 @178 @166 +@572 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @108} -> + {args : @162} -> + {env : @437} -> + {F : @411} -> + {o : @413} -> + (hB : @546) -> + (hfn : @550) -> (hwt : @554) -> (hbind : @484) -> (hF : @494) -> (hA : @558) -> @523 +@573 := @540 @1 +@574 := @541 @1 +@578 := (n : @3) -> @574 @172 @17 @164 +@581 := @152 @178 @166 @471 +@582 := @487 @1 +@585 := @486 (@582 @439) @493 +@586 := @512 @1 +@596 := (hbind : @484) -> + (hF : @585) -> (hA : @558) -> (hne : @502) -> @505 (fun (ro : @504) => @511 (@586 @516 @488 @17)) +@606 := {A : @10} -> + {f : @3} -> + {fn : @108} -> + {args : @162} -> + {env : @437} -> {F : @411} -> {o : @413} -> (hB : @578) -> (hfn : @550) -> (hwt : @581) -> @596 +@607 := @573 @2 +@609 := @574 @2 @17 +@611 := (n : @3) -> @609 @164 +@612 := @158 @166 +@613 := @612 @471 +@622 := {f : @3} -> + {fn : @108} -> + {args : @162} -> + {env : @437} -> {F : @411} -> {o : @413} -> (hB : @611) -> (hfn : @550) -> (hwt : @613) -> @596 +@623 := @607 @98 +@625 := (n : @3) -> @609 @98 +@626 := @547 @98 +@627 := @449 @626 +@628 := @627 @463 +@629 := @582 @98 +@630 := @486 @629 +@631 := @630 @493 +@632 := @555 @98 +@634 := @632 @178 @166 +@636 := @586 (@515 @98) +@644 := (hF : @631) -> (hA : @634) -> (hne : @502) -> @505 (fun (ro : @504) => @511 (@636 @488 @17)) +@653 := {fn : @108} -> + {args : @162} -> + {env : @437} -> + {F : @411} -> {o : @413} -> (hB : @625) -> (hfn : @628) -> (hwt : @613) -> (hbind : @484) -> @644 +@654 := @623 @128 +@656 := @627 (@462 @128) +@657 := @470 @128 +@658 := @612 @657 +@660 := @475 (@476 @128) +@672 := {args : @162} -> + {env : @437} -> + {F : @411} -> + {o : @413} -> + (hB : @625) -> (hfn : @656) -> (hwt : @658) -> (hbind : @474 (@660 @164 @101) @483) -> @644 +@673 := @654 @88 +@675 := @313 (@255 @83) +@677 := @158 @675 @657 +@683 := @84 (@5 @178) (@84 (@51 @172) @83) +@687 := @474 (@660 @683 @101) @483 +@693 := @84 (@5 @465) (@84 (@51 @439) @83) +@695 := @632 @693 @166 +@697 := @84 (@5 @496) +@698 := #12 +@717 := {env : @437} -> + {F : @411} -> + {o : @413} -> + (hB : @625) -> + (hfn : @656) -> + (hwt : @677) -> + (hbind : @687) -> + (hF : @631) -> + (hA : @695) -> + (hne : @502) -> @505 (fun (ro : @504) => @511 (@636 (@697 (@84 (@51 @698) @83)) @17)) +@718 := @673 @106 +@720 := @327 (@269 @83) +@722 := @158 @720 @657 +@733 := @474 (@660 @675 @101) (@482 (@102 (@96 @254) (@102 (@99 @312) @101))) +@739 := @84 (@5 @439) (@84 (@51 @178) @83) +@761 := {F : @411} -> + {o : @413} -> + (hB : @625) -> + (hfn : @656) -> + (hwt : @722) -> + (hbind : @733) -> + (hF : @631) -> + (hA : @632 @739 @166) -> + (hne : @502) -> @505 (fun (ro : @504) => @511 (@636 (@84 (@5 @698) (@84 (@51 @488) @83)) @17)) +@762 := @718 @107 +@763 := @344 @657 +@774 := @474 (@660 @720 @101) (@482 (@102 (@96 @268) (@102 (@99 @326) @101))) +@776 := @630 (@492 @107) +@778 := @632 @683 @166 +@779 := @507 @107 +@801 := {o : @413} -> + (hB : @625) -> + (hfn : @656) -> + (hwt : @763) -> + (hbind : @774) -> + (hF : @776) -> + (hA : @778) -> + (hne : @502) -> + @505 (fun (ro : @504) => @506 (@779 @178 @17) (@636 (@84 (@5 @488) (@84 (@51 @465) @83)) @17)) +@802 := @762 @368 +@803 := @352 @657 +@814 := @474 (@660 @343 @101) (@482 (@102 (@96 @251) (@102 (@99 @309) @101))) +@815 := @632 @675 +@817 := @366 @172 @164 +@818 := @815 @817 +@820 := @366 @178 @172 +@839 := (hB : @625) -> + (hfn : @656) -> + (hwt : @803) -> + (hbind : @814) -> + (hF : @776) -> + (hA : @818) -> + (hne : @414 @820 @419) -> + @505 (fun (ro : @504) => @506 (@779 (@366 @465 @439) @17) (@636 @693 @17)) +@840 := @802 @132 +@841 := @360 @657 +@852 := @474 (@660 @351 @101) (@482 (@102 (@96 @265) (@102 (@99 @323) @101))) +@853 := @632 @720 +@855 := @366 @164 @166 +@874 := (hfn : @656) -> + (hwt : @841) -> + (hbind : @852) -> + (hF : @776) -> + (hA : @853 @855) -> + (hne : @414 @817 @419) -> + @505 (fun (ro : @504) => @506 (@779 (@366 @439 @178) @17) (@636 @739 @17)) +@875 := Eq.refl.{1} +@878 := @840 (@875 @448 @626) +@879 := @364 @657 +@890 := @474 (@660 @359 @101) (@482 (@102 (@96 @280) (@102 (@99 @338) @101))) +@891 := @632 @343 +@893 := @366 @166 @168 +@909 := (hwt : @879) -> + (hbind : @890) -> + (hF : @776) -> + (hA : @891 @893) -> + (hne : @414 @855 @419) -> @505 (fun (ro : @504) => @506 (@779 @820 @17) (@636 @683 @17)) +@910 := @878 @363 +@912 := @660 @88 @101 +@915 := @474 @912 (@482 @106) +@916 := @632 @351 +@918 := @366 @168 @12 +@933 := (hbind : @915) -> + (hF : @776) -> + (hA : @916 @918) -> + (hne : @414 @893 @419) -> @505 (fun (ro : @504) => @506 (@779 @817 @17) (@636 @675 @17)) +@936 := @910 (@875 @473 @912) +@937 := @632 @359 +@939 := @366 @12 @4 +@953 := (hF : @776) -> + (hA : @937 @939) -> + (hne : @414 @918 @419) -> @505 (fun (ro : @504) => @506 (@779 @855 @17) (@636 @720 @17)) +@956 := @936 (@875 @485 @629) +@970 := (hA : @632 @88 @368) -> + (hne : @414 @939 @419) -> @505 (fun (ro : @504) => @506 (@779 @893 @17) (@636 @343 @17)) +@971 := @956 @410 +@982 := (hne : @414 @368 @419) -> @505 (fun (ro : @504) => @506 (@779 @918 @17) (@636 @351 @17)) +@983 := @971 @432 +@989 := @506 (@779 @939 @17) (@636 @359 @17) +@991 := @505 (fun (ro : @504) => @989) +@993 := @505 (fun (__e_ro : @504) => @989) +@994 := LexLeanPreservation.Rust.RepresentableL +@995 := @5 @15 +@997 := @84 @54 @83 +@1000 := @994 (@84 @995 @997) +@1001 := (__e_hrep : @1000) -> @993 +@1002 := fun (__e_hrep : @1000) => @983 +@1003 := (s : @50) -> @1001 +@1004 := fun (s : @50) => @1002 +@1005 := (x : @3) -> @1003 +@1006 := fun (x : @3) => @1004 +\end{coremodule} +\end{lexlean} diff --git a/examples/production-coverage/expected/verify/preserve/audit.txt b/examples/production-coverage/expected/verify/preserve/audit.txt index 7043cc886..c6ec7e5d5 100644 --- a/examples/production-coverage/expected/verify/preserve/audit.txt +++ b/examples/production-coverage/expected/verify/preserve/audit.txt @@ -8065,6 +8065,28 @@ 'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtItems_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_1' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtItems_3' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_4' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_2' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.__wtItems_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wtItems_0' depends on axioms: [propext] +'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.__wt_0' depends on axioms: [propext] -- statement vocabulary inductive LexLeanPreservation.Obs : Type number of parameters: 0 diff --git a/examples/production-coverage/expected/verify/preserve/preservation.json b/examples/production-coverage/expected/verify/preserve/preservation.json index f365c03f6..39420cde7 100644 --- a/examples/production-coverage/expected/verify/preserve/preservation.json +++ b/examples/production-coverage/expected/verify/preserve/preservation.json @@ -1 +1 @@ -{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":57998,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0","program":{"byte_length":19449,"sha256":"1aadfc9ba4fd60d7060d145ef97656e0bca23924ec77e487808d5faae1ada33d"},"renderings":[{"byte_length":85650,"composed":{"byte_length":9211,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd","sha256":"70ec08cf31df3a1371688855f754bd0a4dce09fbb651d2909d9f6e90df0c9d4b","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.root"},"crate":{"byte_length":22556,"sha256":"77ab666847a104f8f578a1f8e741421430e9fed92895817a111f50a95178b620"},"entry":{"function":18,"symbol":"f18"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd","sha256":"9fdbb557e03fc1c14b745580210ab47b56239d046741e78304205f78d2423af2","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.root"}],"root":"Coverage.Boundary.groveRoot","sha256":"78721c55a8a8fdc9c0eb90b586329508e2139a5ff1a8a5855a5255937ac426d9","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.root"},{"byte_length":29473,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1","program":{"byte_length":16945,"sha256":"befbd0f6a81345584eccc0e352073fcc65d585f2ff9b002aad0cfac26a5a426f"},"renderings":[{"byte_length":59928,"composed":{"byte_length":3031,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd","sha256":"d8c00fe0d318715c4025dd96fe78c15e2d61ebbc3bbbed2326756356bdc9c3f5","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd.root"},"crate":{"byte_length":19105,"sha256":"5d5216f8cd8580e08122755e5fd0aa617b9ba4b46fd2dcb000f6d7503c307f92"},"entry":{"function":10,"symbol":"f10"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd","sha256":"931fd2b7ae9e8801742fd99a6a71eaf3a35f1ec50448847ede272394d5239d95","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd.root"}],"root":"Coverage.Colls.mapOps","sha256":"3af528acc5a433558b4cb2231f52d85586c4386c9126c78287765fe7fb4a38e6","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.root"},{"byte_length":13128,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2","program":{"byte_length":4015,"sha256":"db2b0f171e75cff8b9931bc693e039342501c8d43f2d2a653bd29728fe777dc1"},"renderings":[{"byte_length":25017,"composed":{"byte_length":2837,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd","sha256":"2b08107c892e39d0697aa2a8b3f85532a2b15a4ad73034cc6c65a8475985843f","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd.root"},"crate":{"byte_length":15540,"sha256":"014aa5f97db48ae59c8841bf98cd515f65a1be0c24b3fd1095cc48ebb6c83fc1"},"entry":{"function":5,"symbol":"f5"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd","sha256":"360e04e316ab64132239454b9a678d170ff4eac580aaf1b34e239fb4236a0a7c","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd.root"}],"root":"Coverage.Colls.mapFolding","sha256":"03131e35a82f3ed9607ee3232d48706e026c8c77cec76861171cf6d7dc4278c5","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.root"},{"byte_length":26754,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3","program":{"byte_length":16755,"sha256":"ff65cb9f421e37305a20ed392f155a0aabde61713d63520082effd9e2006231d"},"renderings":[{"byte_length":61996,"composed":{"byte_length":2876,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd","sha256":"e7ca504d93337ae8686a37d93a816d0186a2579da374405f69f81f6a08149ec0","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd.root"},"crate":{"byte_length":19344,"sha256":"b735c8c86aaac3de962c4a35440898953b1162fd156ada72eb075744426d87e1"},"entry":{"function":11,"symbol":"f11"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd","sha256":"855ffb6fb58da61afa9c5b5a8e420aab705dbf621f799ef5870972cd04adc43c","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd.root"}],"root":"Coverage.Colls.setOps","sha256":"d3fe677586a97cf780f25e5a147e8176c71d188d241c7fe87d90e7c726c20a04","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.root"},{"byte_length":13311,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4","program":{"byte_length":4435,"sha256":"48b1d22aff3beb88a3f286056475ac74e9a357ff9dc339c89b802249153cebbd"},"renderings":[{"byte_length":21903,"composed":{"byte_length":2676,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd","sha256":"cc2f75fcd8c11dfdcf7d63aa8f74b45b3b4109177da9f20cd6335eddb719811a","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd.root"},"crate":{"byte_length":15272,"sha256":"cf60ae7366ecb8b9565507fd1247024683dfd01ad6d22c2db0aeb6f250c1b307"},"entry":{"function":6,"symbol":"f6"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd","sha256":"efbd52088c08a4f27cf9e63b542534ed1c7d4951b37f12c107f9c7c22a3ea44e","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd.root"}],"root":"Coverage.Colls.folds","sha256":"e5becaee9b2212301f18ee6232b2c608068ea128bcf13f04d6905f93a8fea4bc","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.root"},{"byte_length":9201,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5","program":{"byte_length":3448,"sha256":"17fa1f466a5d992c3b54152d0a758cd23d38d1b2fda1ef5693cc06700cabe223"},"renderings":[{"byte_length":14771,"composed":{"byte_length":1703,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd","sha256":"1f797b6b6311780ca68ad125a97fb2d7f8d125aff0979f5a45ab326ec677c464","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd.root"},"crate":{"byte_length":14251,"sha256":"b07e6313d5996c7f489f6ff31b6047d7bdd30fac8dc0ab06dd2de5c165773171"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd","sha256":"b07366096e6a2743b21a0ac7bcb14ee9dcf002cc78c688baf0c89317d23b6fdb","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd.root"}],"root":"Coverage.Colls.iterations","sha256":"3f630e2eb0d97bf90dec9715d7cbe19b72f242f0516403409eae5eae626c282d","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.root"},{"byte_length":30366,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6","program":{"byte_length":32854,"sha256":"54b3c6a08367cfc9abac0716d282f9bfd50bcfffd1c1c0a5693bf6e6407145e2"},"renderings":[{"byte_length":153083,"composed":{"byte_length":2965,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd","sha256":"1bf7811e2e3b02f4544337c179eceea8df4533a1e5d638ec5fb0b619d86fc1b9","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd.root"},"crate":{"byte_length":28628,"sha256":"d53a1fc1f9cf1f4e7366e8dcf3dea4f3e858227e7739718651f7bd74ea86be6f"},"entry":{"function":30,"symbol":"f30"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd","sha256":"4419e7e384cee221c98f9c12de73633d872974a51c35bad69c02cf2cc11e3f45","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd.root"}],"root":"Coverage.Colls.graphs","sha256":"fb026b62706b883c7648a86ea01b4e9ff252e445c407cb2a33f61a80f7e482fd","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.root"},{"byte_length":19714,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7","program":{"byte_length":17014,"sha256":"bbf596ebb9eca8da32bc60cf81d5aed9f971a815f74ed865dc65f5b5acd7c475"},"renderings":[{"byte_length":82886,"composed":{"byte_length":2743,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd","sha256":"ac1878ff28356b16e32b59fdc7108653251c82b4574fdae2542bc2f650cbeffd","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd.root"},"crate":{"byte_length":21438,"sha256":"b7f9d495a96503043078bb00af86cac5d22f3a92bef084ff7b8d41e5a157014e"},"entry":{"function":15,"symbol":"f15"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd","sha256":"464da95763fed857637d57a46e0e91755a1139caa64cd549d9f0fd5c0fac7b7a","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd.root"}],"root":"Coverage.Colls.stringGraph","sha256":"09ab2fe1857d522c9d88aadb01a4327828ad81f1140ea055d976f00d00b42187","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.root"},{"byte_length":46481,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8","program":{"byte_length":22112,"sha256":"fc3e6614b68e0f0cf2e4fcd7831a0a8ac5a84ade2a42c08eabcd0d2ddc8abe3f"},"renderings":[{"byte_length":117400,"composed":{"byte_length":6533,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd","sha256":"2634d96edc537c1808e6fde87ccbb3ff90094a21224d0dab13f971e13d38b868","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd.root"},"crate":{"byte_length":26043,"sha256":"bf8749dca9d3b9f015f7261c88b60dea927138244a7b63985e6966ad4147d00f"},"entry":{"function":13,"symbol":"f13"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd","sha256":"f9c0efae4c2b0ca1142971facedb30b2758b12b9a892f1458b5487947152a3fc","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd.root"}],"root":"Coverage.Colls.keyTypes","sha256":"54aec705697c6331f7d581d2082a393360784bf1e940a899f52d80d588f62a47","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.root"},{"byte_length":9008,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9","program":{"byte_length":3996,"sha256":"c7a7def9b6c20967b79d34ac878ad3bd945e7e8a5f7ba59728f515c9495f8d2c"},"renderings":[{"byte_length":5833,"composed":{"byte_length":1692,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd","sha256":"126afc446f9597b3c0fb529cbb442f2f442edfa2f6003346965757d6edb22256","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd.root"},"crate":{"byte_length":13175,"sha256":"a33503946fd052ef363ed726a5ef3cab80d9029bf159effcb5ca3ee3f234125d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd","sha256":"714e0fd1a343e93ff58b4cf18048c4afe696d7ef1f838338f00de437f290ef41","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd.root"}],"root":"Coverage.Colls.literals","sha256":"3f19c13eb9bc99f3fc48258ee07a00bd42f13a98db5c5d0f667234b5775df17b","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.root"},{"byte_length":7971,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10","program":{"byte_length":1746,"sha256":"7327b0d3e0e2b92c9e324f0b8f38bf8b9a4866af1fab582ce3cb3471b3faac1f"},"renderings":[{"byte_length":13257,"composed":{"byte_length":1692,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore","sha256":"fe91b1a56fd614b4f4b42f00dd4d904db5a1fc0187fa073aebf00eb0d939ca74","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore.root"},"crate":{"byte_length":4767,"sha256":"af030ef915059e74c7c2a7439cdd2f3e87f0ff1e956993fbdc5ad7c010e3c87a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore","sha256":"edf401f40d710ca8e5313c33366dd137b027163e78f7052cba137f41a92f18cd","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore.root"},{"byte_length":13254,"composed":{"byte_length":1687,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd","sha256":"7b3f27b9bf185bf69c3d455dc6039633db0e85bcb1ab6270a8d3d18aa5e5d803","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd.root"},"crate":{"byte_length":13685,"sha256":"ee0fea13fd0bcd6a8f38ac930442b23f7dcf051f188f1661a7305f3d1e9b69a5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd","sha256":"a5cc548984991c0ac2467cad7008f6ef48daad4e0913ddda42f88f55f8179b3d","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd.root"}],"root":"Coverage.Main.natOps","sha256":"a654af137efbe8d3f97dcf47a8674e85b7bd182fc5157a1314fee817630ece07","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.root"},{"byte_length":4871,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11","program":{"byte_length":772,"sha256":"6f167a8d46f8923a927e311666264729d573c3b8593155abef2114631b1b0283"},"renderings":[{"byte_length":6973,"composed":{"byte_length":1692,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore","sha256":"1c2d82aec429919ce5032898185cd7ddab584727f91e700577ad94ce8d9146a1","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore.root"},"crate":{"byte_length":4340,"sha256":"1fd22968eef8b396fb2c0032d03104ae83717176fc2919b9876d5a2d7a73e0e9"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore","sha256":"b21f6bc827bfe23e4af60ddfea12734a9b8fa3c9a267eead23ccf9fb5b7ae6d4","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore.root"},{"byte_length":6970,"composed":{"byte_length":1687,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd","sha256":"26520eaea9a3a9ce8bf3ad96404b9fc685f9bc87bcabb318a23e8ddf86fa99f9","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd.root"},"crate":{"byte_length":13258,"sha256":"35a8c124f4644cb2f70ee53bb1a4766ebb427587204f1c193338913fdb89fd1c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd","sha256":"1041e5e0943992fe5c2a57fb9aeb8a1b9631d0e35573d8e0e6c6186f10c5ddbc","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd.root"}],"root":"Coverage.Main.intOps","sha256":"dde2b4fc8c3eb3a795292046628f0c4e171ecb60f3e68a95e5d49716922a8f6d","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.root"},{"byte_length":9164,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12","program":{"byte_length":1624,"sha256":"05293367c4a6e86e29d41974b883426e97957fbbc411382de01e1da3e41879c8"},"renderings":[{"byte_length":8984,"composed":{"byte_length":2728,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore","sha256":"06ba735e0cab64ce73b9f2aa4289a87aeacf4e285dd197a45bd5ed33a8e0a9b5","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore.root"},"crate":{"byte_length":4616,"sha256":"9a588c5405d0805e8b71a3c168ecca7d5a7941a10b3707e884a8200765963074"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore","sha256":"15fac79b086f3bac6559db2e0c2feb41e5db8ce590f3ef038da671fac77309ca","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.root"},{"byte_length":8981,"composed":{"byte_length":2720,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd","sha256":"9d97b2c0e59f5b0cdf951edca064f5660f731cf94f63a6d27b72d7ea12979175","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd.root"},"crate":{"byte_length":13534,"sha256":"57df19a47ce392a82bdfe801f4e334b35198361a066b7dd6063f679c07bebbe5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd","sha256":"7f21d7fef55862a50382645a104244928536d274bc7136b5a53dfef03a326a3e","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.root"}],"root":"Coverage.Main.shapes","sha256":"0c98bdd1b5c43f4a39c5ef98c0abc997047ad86f630f9276e3bf795b1928441d","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.root"},{"byte_length":6637,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13","program":{"byte_length":1517,"sha256":"43b6eedb7829b3598a29348c532e07d70295631eb2650df5de98d38c3daccb35"},"renderings":[{"byte_length":7237,"composed":{"byte_length":2336,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd","sha256":"f7b54c4e4ede4c77ba528f4595f141fa5c3913f75fcc154289cf2ae1d183f417","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd.root"},"crate":{"byte_length":13479,"sha256":"92cec27dd560e7ca0a9f5daa440567b51beb597b69ef56f0678a55f0729d1198"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd","sha256":"3f0808374ddb86f7cb931036b058e580dddd14e892bbfad83004e29233186842","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.root"}],"root":"Coverage.Main.treeTotal","sha256":"e1057527317e1ffaa0b259b01bd31534b1571c59ca55a278996ac931def155b7","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.root"},{"byte_length":6646,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14","program":{"byte_length":1628,"sha256":"f6c459c7f8163810d05bc43460cd394578f415d182096e2ad51dae6252d4f656"},"renderings":[{"byte_length":7066,"composed":{"byte_length":3771,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore","sha256":"f664b3981dda8911a645730aa15f5fd14686bbc2f9dc6032bd2ecd8b507ea1db","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.root"},"crate":{"byte_length":4685,"sha256":"73a3e27a1326d458fa653a2a3b7057649a690cfc50441d306fc0456004f12045"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore","sha256":"5448c7fcf866f8da57a361278141d537b1c3d559f39ee9b588ef9168a5b8e59f","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.root"},{"byte_length":7063,"composed":{"byte_length":3757,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd","sha256":"d386ce43cda39a827c4b8c7a0bb7abe1af9e56139cecb9e1f5fb44f361769c6a","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.root"},"crate":{"byte_length":13603,"sha256":"4b8bab9cd36b1b9026cb5992a83d73f087c3a70988458b0e1f559b5e0d15d812"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd","sha256":"8efd91cd37e2eb523985e73399aacfc123de5b031a8ee34f7d367dfad40dd4c0","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.root"}],"root":"Coverage.Main.records","sha256":"c3aac043aac68fdf99843da0ca6296995661d6d975de42ff6a0c58a6d8267cc0","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.root"},{"byte_length":5198,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15","program":{"byte_length":989,"sha256":"1817e8488f6542ec7a9c65ee73a26b9b2ce35ef18dad904d897c9dded6e3cbf9"},"renderings":[{"byte_length":5464,"composed":{"byte_length":2095,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore","sha256":"5e714bf6417b27e1fd6e015d9495ae0f11706703414a907687cff15d1440ef2b","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore.root"},"crate":{"byte_length":4417,"sha256":"31aa7ca5ef4e02642fd2c913c93293b098b0b55555ebd261df0377b68180139e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore","sha256":"2fba9e0869c454c869ef425d41fe585f3583feab047d12e51ce373b18b094732","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore.root"},{"byte_length":5461,"composed":{"byte_length":2090,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd","sha256":"f0504d93d749a2506f100edaf972b46195e4f3ca6b9b87281b808e102ff1fcde","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd.root"},"crate":{"byte_length":13335,"sha256":"44fa70d0448251f98e8fdef3403a5990d6a42239304a80f10cb6830960f7268d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd","sha256":"95f3893e6bb0ef1b3da615ba9751c0097466916f259558ffe0a6cca5cc97464a","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd.root"}],"root":"Coverage.Main.options","sha256":"5e56681ac37f6c0da09a87922d5d46962f45772af43d9cd4d6aa7746e364535b","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.root"},{"byte_length":4914,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16","program":{"byte_length":1264,"sha256":"234deee526474348f12566f97e315f4a79becf0607138d82ae06f555a4d3f2db"},"renderings":[{"byte_length":3982,"composed":{"byte_length":1494,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore","sha256":"1ec1dc64eb78733dae0643b65020ebd2d9801ba2610997b43f67b6e99ddafd58","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore.root"},"crate":{"byte_length":4121,"sha256":"84aab30692ec8281062085a409bfc422cd779958bb5c57ef9e59799a768d2501"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore","sha256":"40ebd3a567efeb207027d035c385801538753d07ad7dcce2ad4574672f674cd7","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore.root"},{"byte_length":3979,"composed":{"byte_length":1489,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd","sha256":"a563b3c23fc3dcb2c8c322423f5566e6f1a304758888255733e5fcad8f90672c","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd.root"},"crate":{"byte_length":13039,"sha256":"6d8bc511c7f98f686d36dbda86f3c9a344a7dcdf69021b28be933128dcaaae78"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd","sha256":"a62758c506548a14dde70849045c47d127af57b15126fd08ec1f79ede7c03bf2","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd.root"}],"root":"Coverage.Main.builders","sha256":"ee60e433bc97680ac58c0b3415e59c5dea3d79c8929f36e166ec34d351bfaded","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.root"},{"byte_length":2718,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17","program":{"byte_length":451,"sha256":"7d925a72d07005baaa5a9371f60e52199072e49139630af3348972394ef0539f"},"renderings":[{"byte_length":2405,"composed":{"byte_length":1756,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore","sha256":"e99fb154299ee32d8644e5affe6bac23c1353aee309a2aa2e9c0e86c13fd2b6c","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore.root"},"crate":{"byte_length":4003,"sha256":"9ee584eed11f7b4efb99475c2a6b35939dc35dd3f263806aec3ae84479b96685"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore","sha256":"9f93bed1eac77aaa3ca3bd9a8a7e199705606ff720e40398f1f51ddca5258016","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore.root"},{"byte_length":2402,"composed":{"byte_length":1751,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd","sha256":"f96192b1f715629bdd005cb44daf2ddefe7fe5f89996337768397538e3dcec23","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd.root"},"crate":{"byte_length":12921,"sha256":"5e115227d6075aa279430638e5ddb6995ac255db0bd608e107a843bd468dde51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd","sha256":"5b51e4fcd5bd2beb0d2f4c4f861ec842658bd49ccf48fac1a39d6a453103209c","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd.root"}],"root":"Coverage.Main.pairs","sha256":"884b9ac3166543a1a480fbb0d99a9f74552a833cdece54ca2ba3bbfa337acbf6","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.root"},{"byte_length":10732,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18","program":{"byte_length":1873,"sha256":"b9a631ceb72fc1536c7c26c88ce17cb71084492929763dc601a2e579e3b15596"},"renderings":[{"byte_length":12456,"composed":{"byte_length":1740,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore","sha256":"28c228f2b4408add7637254df3e401f12630d1277d76aba4f5c9a0b9e74dc489","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore.root"},"crate":{"byte_length":5047,"sha256":"2c1e15094b24d3e5c9a0a06315afc8bf4c60341ba27fd1bf252230213141f5fe"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore","sha256":"f0f364a8086fff5df4288f0aca5764991968b85915bcb9834ac5a761933cdd05","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore.root"},{"byte_length":12453,"composed":{"byte_length":1735,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd","sha256":"331e69cbad435fd8f59f867f47d5e61d6241c1a678c43669192b09c512dc29a8","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd.root"},"crate":{"byte_length":13965,"sha256":"d46d5bf325126545575bdf8963f16739be5cfb777b38c5233acf8ea8c474a576"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd","sha256":"0836bf8a7de7af1510c422ea43e43a38e19f76d414e244c030b93ddbce0143a6","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd.root"}],"root":"Coverage.Main.higher","sha256":"68d3ebd1e9ce8bd045ebc93eb1634347e7f5e2364f136e00237ec401bf186f84","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.root"},{"byte_length":8621,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19","program":{"byte_length":1884,"sha256":"83625b33701e16e8f1014fd8a942ea0ac67a87cefb2ef0f93321f9dbc4bbe943"},"renderings":[{"byte_length":7953,"composed":{"byte_length":1646,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd","sha256":"3f1c3a4b752000be28581fe4a164afb64086ab39e4c51beb00cc8dcbd37b034e","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd.root"},"crate":{"byte_length":13607,"sha256":"ffd9d2b0d04acb6874cfa5f2983560a9c24a75e8bbd9f3b2580f84d5a76d7b70"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd","sha256":"0a7cc7d94c946e8615f0a55f63353ef660c85832e3e6b5b15bc83548a1d9457a","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd.root"}],"root":"Coverage.Main.mapped","sha256":"1993d9aec62e222d1336a4257cba1111d820811436e6446fbec087e01b986a3b","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.root"},{"byte_length":4983,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20","program":{"byte_length":999,"sha256":"d80d8fa87a73970b99d0429236be199dba9bdbb4207a8c64505ec3f999bc2775"},"renderings":[{"byte_length":4204,"composed":{"byte_length":1495,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore","sha256":"8253af593fedb08d78c99b65a10a947fadd53de89f962a56332d36d235f4ee32","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore.root"},"crate":{"byte_length":4179,"sha256":"fcb23d2bf0050b3ce8c890495631aa62147613e0a92836750e7c5fd2bb3b60dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore","sha256":"c63b83146c15afd118af18a6edf1e6b052d34605720b32d577899d64c25ccaab","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore.root"},{"byte_length":4201,"composed":{"byte_length":1490,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd","sha256":"819fb4cb11c3b47db5a98777722abc2ccc2266209cf90e76f6fb7e4bfec754a3","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd.root"},"crate":{"byte_length":13097,"sha256":"a9de1e3631675db5a707a20a389993cdccd26644956d0ad09e14a25f26b8123f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd","sha256":"992a5cd39d95182550754100ecb06642210af8690474115b5347c57c73b88f2e","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd.root"}],"root":"Coverage.Main.parity","sha256":"58943dcfa3ab52f2bdf3e4148b43213ff5f1142b8141b764642e3ef95fd0cea5","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.root"},{"byte_length":6865,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21","program":{"byte_length":2446,"sha256":"ef7c0ba20d049db4524a6ec6561a20d86bd33230f60e21dc733706135be42f2d"},"renderings":[{"byte_length":7321,"composed":{"byte_length":1689,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore","sha256":"84fa953b51a122df51ba4f4dc79abe8e6ff140b32f6f453fd730535ea4e5997a","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore.root"},"crate":{"byte_length":4385,"sha256":"f4884b32be79ba4577ae148c340ffd389f3ab673bab9b3e0a6151d92a64dac98"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore","sha256":"f1071c942a06fa2989bd7d53d525f1a44675c3ab1104ec1bec0f5ca0608df418","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore.root"},{"byte_length":7318,"composed":{"byte_length":1684,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd","sha256":"6b7f5b387c1ee032f0b499ff54e1f8a27a4ab5f237712d26570ff04e08d0a68a","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd.root"},"crate":{"byte_length":13303,"sha256":"a09d0b574d6829f8ce94552a82e7770388c891bf3591aef3bdb2aa1c80734465"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd","sha256":"b56adc091e4cd71d045e3c70e5a8d248c47406185bc3de8e9f63e6ab0ff92a2f","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd.root"}],"root":"Coverage.Prims.fixedSmall","sha256":"07946fec25c51d667c09f243b7157adca2f414d2676616da4a0aead5619867d9","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.root"},{"byte_length":5605,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22","program":{"byte_length":1770,"sha256":"c5c4a8ee12a3a426500bb6c4e82af761e1af447511bd597e1bc5dce63970ddaf"},"renderings":[{"byte_length":5884,"composed":{"byte_length":1697,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore","sha256":"f23a844f88b2a0c0b196bb762aee26d5176b8b7606766a83472bdccab2097862","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore.root"},"crate":{"byte_length":4285,"sha256":"9ad73a749e8c19c7038a85d6fd571a10e3024158934cfc17d738099d4257e7c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore","sha256":"a40b3b67713565517cd7eb9433b0be2b0dade8c72351038bee39b798614356f4","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore.root"},{"byte_length":5881,"composed":{"byte_length":1692,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd","sha256":"a35cd2918688173e74b0fdbb8041c4290cf914c1f6ce19187d972771f063dfda","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd.root"},"crate":{"byte_length":13203,"sha256":"2e31d2ad0160635ba75b00c7c15bc08e71de244c902defb8fddb06175c8752e4"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd","sha256":"a083cf7b7887c7e14b78bcdac2430aff96cb49526e743ec48fa3aecbce9c71a1","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd.root"}],"root":"Coverage.Prims.fixedMiddle","sha256":"c964b94b1f222773f1aada17af571aeb5a59e7aec55e30a98e00f80bfbba00e6","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.root"},{"byte_length":8520,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23","program":{"byte_length":3324,"sha256":"046e9276a504b885d2582f97b9c4fb34281d09496a6f649c6c147f6361e56c8d"},"renderings":[{"byte_length":8909,"composed":{"byte_length":1898,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore","sha256":"bf8519dae916026012660815810b784ea178a1b208aa16fd18f549cc8bca985a","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore.root"},"crate":{"byte_length":4519,"sha256":"e68ee92c192814f24ef49f678d7b0f10e590262eaac0e5a5edafd2716711b54f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore","sha256":"d1ebf2579e50cd471af7d2eb3bde9acac9c3260d885e35a2a3ed2f8e2580bd98","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore.root"},{"byte_length":8906,"composed":{"byte_length":1893,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd","sha256":"87ffcd2284bc07703356ef60ebe203e55560a4489e5c0178816652bdf04b2b51","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd.root"},"crate":{"byte_length":13437,"sha256":"2f8e04183e437e3b85961d1277fa70eec93662dd97eb0e6e4f0d1d1adfc95798"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd","sha256":"2af8ef16e05d2455c638a487e1d4b73c4817f098684dba99ebf37566da30d106","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd.root"}],"root":"Coverage.Prims.fixedWide","sha256":"bc47ef5c49501fa1efbe86502b850b017370f06a5f52ea6906baed55dd22f54e","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.root"},{"byte_length":8690,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24","program":{"byte_length":3494,"sha256":"9ed3cf1ba1de6ddfd0c865acea0ee413b21ac44fb1d556e8eac704b552c3d018"},"renderings":[{"byte_length":9917,"composed":{"byte_length":1900,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore","sha256":"8094d02b256f903685f388e99083b57e7091df5022bdcd663fa34e985f3fbf3b","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore.root"},"crate":{"byte_length":4562,"sha256":"f594bce05710d6a44ba4db5022a8759b6ac698bed7b389b7e60d820c93373a21"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore","sha256":"86c68cf1725cbee72359b2bb72275c234bdfc2c8a3aeb31f266124d04b798487","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore.root"},{"byte_length":9914,"composed":{"byte_length":1895,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd","sha256":"9b545ec552276be6721035fdd3eca13f7480d9b814fc5e72347af7e899fe9402","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd.root"},"crate":{"byte_length":13480,"sha256":"34ed06527b7da3dc36936034ff6c7a0145675fd668c22ed6feafa9a3b418e3bf"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd","sha256":"9f17e18541cc6e479bb37fd57b170dc3a1c2e7b1069aedba30acc7db3ca61007","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd.root"}],"root":"Coverage.Prims.bits","sha256":"09465c147273246c491c6b919c4703e42989b3fb4480b92baff2cf7540ca4bca","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.root"},{"byte_length":3336,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25","program":{"byte_length":701,"sha256":"6227207e0bebaa6609e8bfedfaffb83e7fcb5e8c11d9ed9caaa35fb65b35766f"},"renderings":[{"byte_length":2932,"composed":{"byte_length":1691,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore","sha256":"f20d19de54bcb73f2f80359f01069e964a2597d2d037be7d3e8117e6a59e5257","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore.root"},"crate":{"byte_length":4072,"sha256":"177164e24d17c1a066fd7038902d01c1f8dfd73c69ed8377af3b1c2db5cc1412"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore","sha256":"0f402e373332ae85a115781d4e9e2582f263aa30cf71b554ca73d0eb623472a7","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore.root"},{"byte_length":2929,"composed":{"byte_length":1686,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd","sha256":"b9c3afffa8d7a5781b7a13810886315374c5f862ad54183b269ced0297fe1695","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd.root"},"crate":{"byte_length":12990,"sha256":"2f5c6ff9563847b0e68f1b9b206d825a78c81a047a954fd54ab509b3bd79de61"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd","sha256":"048faad3c13980a53edbc0f89e15a643430897621d4c56326cc6b83e9839e9c8","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd.root"}],"root":"Coverage.Prims.conversions","sha256":"a79055932efffcf929c88bc91b7d2d85c9ed2ced2b3b05b5c422793a6bd1d140","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.root"},{"byte_length":14059,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26","program":{"byte_length":5637,"sha256":"c01fc096fdf4c89e91adb6928197ce32bcb7e42426af0487546f4edc98fd3702"},"renderings":[{"byte_length":16373,"composed":{"byte_length":2029,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd","sha256":"13af0b6ae81feac5daa2bc00f76abbf87ccb69b7dea7c2c7c8f86ef9749e9d96","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd.root"},"crate":{"byte_length":14078,"sha256":"64aebfe2ed7b706cea90fb4e7ee5b7630cb43e480aa43f74e6fe9af4c4142601"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd","sha256":"89fbea3cee495254e7347ebe6988ec09bbf5d808039940c8094cd2915ebd2896","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd.root"}],"root":"Coverage.Prims.sequences","sha256":"0bd5e9affa68f94728bf2ff2a621b60833a106c3d5239020f765f7c386ce65b2","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.root"},{"byte_length":3214,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27","program":{"byte_length":686,"sha256":"6fc888e3f1e9cf5a37f9f68cc01d1a1ff94cc30a552b384155cb811a9d13a526"},"renderings":[{"byte_length":2818,"composed":{"byte_length":1501,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd","sha256":"40924a4f0e13ff66d9be13e8b43a3acae04750ff8065e86ab906157b9544ad7f","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd.root"},"crate":{"byte_length":12956,"sha256":"11b389208a11b50ffd36526d42d3b92b00669a700b8875d53bef97f92efd7c8a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd","sha256":"c3b055b7a3382a0898fce7f736aca5bd5c9fa966c14c896d5d255dc8034e8e3c","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd.root"}],"root":"Coverage.Prims.decimals","sha256":"f7f7f28872c2a8d9889d8ca8ff542269a29642e82ebffb154dea121680fc1a29","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.root"},{"byte_length":3046,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28","program":{"byte_length":529,"sha256":"a2d6d8d674af0354e10f236b2b6dcab2579a6ff9db94b3a696fb2c0679df7372"},"renderings":[{"byte_length":2791,"composed":{"byte_length":1686,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd","sha256":"1f94483e1442d1827bfb306ebd938ec190e52b0c80061c0d61cc8011a5ed0ea0","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd.root"},"crate":{"byte_length":12933,"sha256":"d0b018bf12ebfd193d45370c9a299fe8448a30481f706e8bcf5a756c78b6359e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd","sha256":"fcefb2ac0c0666a3997f9527f64a583bd1e550983d1c7cc1f31dc1369c981672","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd.root"}],"root":"Coverage.Prims.formats","sha256":"12359f0159434ecfdcf4ba04f033866b5a72832f06b61c2417e50c437bf55bc4","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.root"},{"byte_length":11694,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29","program":{"byte_length":4118,"sha256":"54080023d9f656975c8d23e285159c2f80184d9c38941ebdeb9b115207eaea0f"},"renderings":[{"byte_length":14927,"composed":{"byte_length":1712,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd","sha256":"d557333d41e93807e456e432f4841400ae29c4f92c2b6d334cec875453250cdd","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd.root"},"crate":{"byte_length":13981,"sha256":"e4aba3ad1a43ca155a88aec769bcc47479e9e5091944214f2a469ca7b68e7d9c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd","sha256":"2c4c5160d758f11b1f7dec18c1520cc0f7536c37744e504c84cad05924f75a27","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd.root"}],"root":"Coverage.Prims.text","sha256":"9d762bb3183931a74cc8f4c240b22b9dc5c5664b3ee02d3ecdffef8f527bb9ec","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.root"},{"byte_length":8119,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30","program":{"byte_length":1887,"sha256":"023b87970dcc71c4e8be45aa676e75b9db5753e3da5f8ac416891d595dca8b41"},"renderings":[{"byte_length":7705,"composed":{"byte_length":2793,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd","sha256":"cc80880f424636418515aeeed1e9fa97baffe9a3e930adb990af12e4d1a92737","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.root"},"crate":{"byte_length":13423,"sha256":"7b6d66e610ef88eda88943c88c3322a2c1bf519e41049d16afe53d039cd7033a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd","sha256":"e25f62db5dbc7a6b49f1001ed8c96462d379afde7a161bcdad95222128f7c531","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.root"}],"root":"Coverage.RecRoots.roseTotal","sha256":"448333ca274e3ff20bd3547e96cbcbbb840de4c7c4aa7b681ed2c81ebc4e83a5","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.root"},{"byte_length":12655,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31","program":{"byte_length":2687,"sha256":"0b283960a85e885aef98cffde5a37a5840fe6905cb960332eb57755a9f588e7b"},"renderings":[{"byte_length":15589,"composed":{"byte_length":4165,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd","sha256":"b9471c54fcd58270f3948989130d81e2b74ed32c93b062744bc8adddbe8335f4","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.root"},"crate":{"byte_length":14339,"sha256":"3c3d755be5666a0def8f507f530fa6c1b75ce74ae299363b69cdd7f19b598674"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd","sha256":"52211fc39045577478484827fe2ffd6420834befbb418ecc7d2c2787ad9c36e9","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.root"}],"root":"Coverage.RecRoots.syntaxTotal","sha256":"a5ab58f17283c3e4b9c0738fd2530ec91bb600a34e7ed66c89b4b41fb701756d","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.root"},{"byte_length":17232,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32","program":{"byte_length":3120,"sha256":"a30548452b5811cfc83abdc547d7e93bbdfaf6ae193442225eed19b212b84e5d"},"renderings":[{"byte_length":19234,"composed":{"byte_length":1692,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore","sha256":"d64eb27716f1706b08a478d0ea688d662c98fad37c391c3f566e1b554b058c7f","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore.root"},"crate":{"byte_length":5179,"sha256":"595b9659cce79629fb199be239edeba9f908e19c5863ec7fc71ddbea1ca6b16d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore","sha256":"299a8e60e31250a605d9157a3bc705bacc36f9f4d818ab831cdcc850693ac089","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore.root"},{"byte_length":19231,"composed":{"byte_length":1687,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd","sha256":"a8260359e6842146e0e37e3bbd25d30aec3e29d3b8c041831a19ead2cfbfa425","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd.root"},"crate":{"byte_length":14097,"sha256":"5bde24114f0f63beca1277bf6cd06ea203bd89352590534d5844f6639bbeb943"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd","sha256":"025789ce61c2fb28f6d19b5475f235681a08f19fbb2ea4e68ce0e12939c38de5","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd.root"}],"root":"Coverage.RecRoots.wellFounded","sha256":"179e94c9f3f93fa7a686a4d42a5e3f12a42d8f94c4ed8f2b5a33649ef89d87fe","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.root"},{"byte_length":15632,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33","program":{"byte_length":2757,"sha256":"696084d3a568dde72c41261e20eb3e6dfc3055d9f56ddb2a9980a5b1eb061f89"},"renderings":[{"byte_length":13569,"composed":{"byte_length":2380,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd","sha256":"722b40cd054d97c5e3eaf1dd7b75d63ca1b9ba1341da342addf9c2636b2752c9","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.root"},"crate":{"byte_length":14222,"sha256":"85ddef0fbc268b258386fd1d552610372cf646edbeda718288d5bc4554a58de0"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd","sha256":"c9346b2d91265923067b800cb139432d9a262e343bc900cc75edbb3c3361942a","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.root"}],"root":"Coverage.RecRoots.rewrite","sha256":"886c89f5c5879c15c48f3ea5c5a77888885cbd96f01e568a9e63a23eca851137","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":57998,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0","program":{"byte_length":19449,"sha256":"1aadfc9ba4fd60d7060d145ef97656e0bca23924ec77e487808d5faae1ada33d"},"renderings":[{"byte_length":85650,"composed":{"byte_length":57221,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd","sha256":"b90337e106179d0d8c64ca2c96388d2355099c773b06aa3094a2830286799c8e","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.root"},"crate":{"byte_length":22556,"sha256":"77ab666847a104f8f578a1f8e741421430e9fed92895817a111f50a95178b620"},"entry":{"function":18,"symbol":"f18"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd","sha256":"9fdbb557e03fc1c14b745580210ab47b56239d046741e78304205f78d2423af2","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.root"}],"root":"Coverage.Boundary.groveRoot","sha256":"78721c55a8a8fdc9c0eb90b586329508e2139a5ff1a8a5855a5255937ac426d9","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.root"},{"byte_length":29473,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1","program":{"byte_length":16945,"sha256":"befbd0f6a81345584eccc0e352073fcc65d585f2ff9b002aad0cfac26a5a426f"},"renderings":[{"byte_length":59928,"composed":{"byte_length":21729,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd","sha256":"535fd3506a57527682f92a59dc93dfe93c19fad7bca35043afe7ae9c645de799","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd.root"},"crate":{"byte_length":19105,"sha256":"5d5216f8cd8580e08122755e5fd0aa617b9ba4b46fd2dcb000f6d7503c307f92"},"entry":{"function":10,"symbol":"f10"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd","sha256":"931fd2b7ae9e8801742fd99a6a71eaf3a35f1ec50448847ede272394d5239d95","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd.root"}],"root":"Coverage.Colls.mapOps","sha256":"3af528acc5a433558b4cb2231f52d85586c4386c9126c78287765fe7fb4a38e6","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.root"},{"byte_length":13128,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2","program":{"byte_length":4015,"sha256":"db2b0f171e75cff8b9931bc693e039342501c8d43f2d2a653bd29728fe777dc1"},"renderings":[{"byte_length":25017,"composed":{"byte_length":19445,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd","sha256":"461045a8efd6bffd4f91b97e3239337b3fc26f467c842cec73b49de3b8659d60","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd.root"},"crate":{"byte_length":15540,"sha256":"014aa5f97db48ae59c8841bf98cd515f65a1be0c24b3fd1095cc48ebb6c83fc1"},"entry":{"function":5,"symbol":"f5"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd","sha256":"360e04e316ab64132239454b9a678d170ff4eac580aaf1b34e239fb4236a0a7c","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd.root"}],"root":"Coverage.Colls.mapFolding","sha256":"03131e35a82f3ed9607ee3232d48706e026c8c77cec76861171cf6d7dc4278c5","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.root"},{"byte_length":26754,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3","program":{"byte_length":16755,"sha256":"ff65cb9f421e37305a20ed392f155a0aabde61713d63520082effd9e2006231d"},"renderings":[{"byte_length":61996,"composed":{"byte_length":18245,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd","sha256":"e0f433b5dabade6cc1572ea9d28492ba492fcb86d90c4481573d7c6d8b52fdf2","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd.root"},"crate":{"byte_length":19344,"sha256":"b735c8c86aaac3de962c4a35440898953b1162fd156ada72eb075744426d87e1"},"entry":{"function":11,"symbol":"f11"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd","sha256":"855ffb6fb58da61afa9c5b5a8e420aab705dbf621f799ef5870972cd04adc43c","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd.root"}],"root":"Coverage.Colls.setOps","sha256":"d3fe677586a97cf780f25e5a147e8176c71d188d241c7fe87d90e7c726c20a04","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.root"},{"byte_length":13311,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4","program":{"byte_length":4435,"sha256":"48b1d22aff3beb88a3f286056475ac74e9a357ff9dc339c89b802249153cebbd"},"renderings":[{"byte_length":21903,"composed":{"byte_length":17987,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd","sha256":"f86dc433036546e60a120f338503a9a034a8ef104b82cf406eb5098696abcc81","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd.root"},"crate":{"byte_length":15272,"sha256":"cf60ae7366ecb8b9565507fd1247024683dfd01ad6d22c2db0aeb6f250c1b307"},"entry":{"function":6,"symbol":"f6"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd","sha256":"efbd52088c08a4f27cf9e63b542534ed1c7d4951b37f12c107f9c7c22a3ea44e","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd.root"}],"root":"Coverage.Colls.folds","sha256":"e5becaee9b2212301f18ee6232b2c608068ea128bcf13f04d6905f93a8fea4bc","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.root"},{"byte_length":9201,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5","program":{"byte_length":3448,"sha256":"17fa1f466a5d992c3b54152d0a758cd23d38d1b2fda1ef5693cc06700cabe223"},"renderings":[{"byte_length":14771,"composed":{"byte_length":13364,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd","sha256":"f8bc5d2ee0ce749f192d080d60e7b268d129bb33e4e978af9cb7382293d46edf","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd.root"},"crate":{"byte_length":14251,"sha256":"b07e6313d5996c7f489f6ff31b6047d7bdd30fac8dc0ab06dd2de5c165773171"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd","sha256":"b07366096e6a2743b21a0ac7bcb14ee9dcf002cc78c688baf0c89317d23b6fdb","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd.root"}],"root":"Coverage.Colls.iterations","sha256":"3f630e2eb0d97bf90dec9715d7cbe19b72f242f0516403409eae5eae626c282d","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.root"},{"byte_length":30366,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6","program":{"byte_length":32854,"sha256":"54b3c6a08367cfc9abac0716d282f9bfd50bcfffd1c1c0a5693bf6e6407145e2"},"renderings":[{"byte_length":153083,"composed":{"byte_length":20096,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd","sha256":"357efdec9740001f1d6bfd373f667648ae701383490df678ae59baade6a6d0a2","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd.root"},"crate":{"byte_length":28628,"sha256":"d53a1fc1f9cf1f4e7366e8dcf3dea4f3e858227e7739718651f7bd74ea86be6f"},"entry":{"function":30,"symbol":"f30"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd","sha256":"4419e7e384cee221c98f9c12de73633d872974a51c35bad69c02cf2cc11e3f45","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd.root"}],"root":"Coverage.Colls.graphs","sha256":"fb026b62706b883c7648a86ea01b4e9ff252e445c407cb2a33f61a80f7e482fd","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.root"},{"byte_length":19714,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7","program":{"byte_length":17014,"sha256":"bbf596ebb9eca8da32bc60cf81d5aed9f971a815f74ed865dc65f5b5acd7c475"},"renderings":[{"byte_length":82886,"composed":{"byte_length":18641,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd","sha256":"92f0cf3b9d15c25b517cd7a9537816b311d7e045e211764b1722620ba61db82c","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd.root"},"crate":{"byte_length":21438,"sha256":"b7f9d495a96503043078bb00af86cac5d22f3a92bef084ff7b8d41e5a157014e"},"entry":{"function":15,"symbol":"f15"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd","sha256":"464da95763fed857637d57a46e0e91755a1139caa64cd549d9f0fd5c0fac7b7a","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd.root"}],"root":"Coverage.Colls.stringGraph","sha256":"09ab2fe1857d522c9d88aadb01a4327828ad81f1140ea055d976f00d00b42187","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.root"},{"byte_length":46481,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8","program":{"byte_length":22112,"sha256":"fc3e6614b68e0f0cf2e4fcd7831a0a8ac5a84ade2a42c08eabcd0d2ddc8abe3f"},"renderings":[{"byte_length":117400,"composed":{"byte_length":45654,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd","sha256":"e055d044cdeed092caac47968020322c1cd76c0b32767227965c307647a808ec","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd.root"},"crate":{"byte_length":26043,"sha256":"bf8749dca9d3b9f015f7261c88b60dea927138244a7b63985e6966ad4147d00f"},"entry":{"function":13,"symbol":"f13"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd","sha256":"f9c0efae4c2b0ca1142971facedb30b2758b12b9a892f1458b5487947152a3fc","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd.root"}],"root":"Coverage.Colls.keyTypes","sha256":"54aec705697c6331f7d581d2082a393360784bf1e940a899f52d80d588f62a47","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.root"},{"byte_length":9008,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9","program":{"byte_length":3996,"sha256":"c7a7def9b6c20967b79d34ac878ad3bd945e7e8a5f7ba59728f515c9495f8d2c"},"renderings":[{"byte_length":5833,"composed":{"byte_length":14316,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd","sha256":"465b153bec804ec0a9ec51c3be62f979ad36baa948aa4b92144d6b7bc2896835","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd.root"},"crate":{"byte_length":13175,"sha256":"a33503946fd052ef363ed726a5ef3cab80d9029bf159effcb5ca3ee3f234125d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd","sha256":"714e0fd1a343e93ff58b4cf18048c4afe696d7ef1f838338f00de437f290ef41","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd.root"}],"root":"Coverage.Colls.literals","sha256":"3f19c13eb9bc99f3fc48258ee07a00bd42f13a98db5c5d0f667234b5775df17b","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.root"},{"byte_length":7971,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10","program":{"byte_length":1746,"sha256":"7327b0d3e0e2b92c9e324f0b8f38bf8b9a4866af1fab582ce3cb3471b3faac1f"},"renderings":[{"byte_length":13257,"composed":{"byte_length":13207,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore","sha256":"1fd1866a30403174b1a0cf225a366dc362c5031f3901ca24dd317ea293ed68ed","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore.root"},"crate":{"byte_length":4767,"sha256":"af030ef915059e74c7c2a7439cdd2f3e87f0ff1e956993fbdc5ad7c010e3c87a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore","sha256":"edf401f40d710ca8e5313c33366dd137b027163e78f7052cba137f41a92f18cd","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore.root"},{"byte_length":13254,"composed":{"byte_length":13198,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd","sha256":"b4410877d8d65583a091defca4fc71b3d1013a974dac34645ccc4ee9214f87ad","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd.root"},"crate":{"byte_length":13685,"sha256":"ee0fea13fd0bcd6a8f38ac930442b23f7dcf051f188f1661a7305f3d1e9b69a5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd","sha256":"a5cc548984991c0ac2467cad7008f6ef48daad4e0913ddda42f88f55f8179b3d","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd.root"}],"root":"Coverage.Main.natOps","sha256":"a654af137efbe8d3f97dcf47a8674e85b7bd182fc5157a1314fee817630ece07","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.root"},{"byte_length":4871,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11","program":{"byte_length":772,"sha256":"6f167a8d46f8923a927e311666264729d573c3b8593155abef2114631b1b0283"},"renderings":[{"byte_length":6973,"composed":{"byte_length":13231,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore","sha256":"e4d830efaa2c5df22d57a7392fc67abd18ff2c8cae52d114f0aff942511a23b7","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore.root"},"crate":{"byte_length":4340,"sha256":"1fd22968eef8b396fb2c0032d03104ae83717176fc2919b9876d5a2d7a73e0e9"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore","sha256":"b21f6bc827bfe23e4af60ddfea12734a9b8fa3c9a267eead23ccf9fb5b7ae6d4","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore.root"},{"byte_length":6970,"composed":{"byte_length":13222,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd","sha256":"c975ec0ad89b63207b04e875261d5c34cadba17f797db6d114bccb1c87762d3c","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd.root"},"crate":{"byte_length":13258,"sha256":"35a8c124f4644cb2f70ee53bb1a4766ebb427587204f1c193338913fdb89fd1c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd","sha256":"1041e5e0943992fe5c2a57fb9aeb8a1b9631d0e35573d8e0e6c6186f10c5ddbc","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd.root"}],"root":"Coverage.Main.intOps","sha256":"dde2b4fc8c3eb3a795292046628f0c4e171ecb60f3e68a95e5d49716922a8f6d","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.root"},{"byte_length":9164,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12","program":{"byte_length":1624,"sha256":"05293367c4a6e86e29d41974b883426e97957fbbc411382de01e1da3e41879c8"},"renderings":[{"byte_length":8984,"composed":{"byte_length":17187,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore","sha256":"c03ac25ff46411d456e3202598a12cfa179ae3ff9fbe686b21ec401dca16d780","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore.root"},"crate":{"byte_length":4616,"sha256":"9a588c5405d0805e8b71a3c168ecca7d5a7941a10b3707e884a8200765963074"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore","sha256":"15fac79b086f3bac6559db2e0c2feb41e5db8ce590f3ef038da671fac77309ca","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.root"},{"byte_length":8981,"composed":{"byte_length":17176,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd","sha256":"083330e07d97169cf81520e7030e6bdea6304cbc2c237bc6406c611fae879125","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd.root"},"crate":{"byte_length":13534,"sha256":"57df19a47ce392a82bdfe801f4e334b35198361a066b7dd6063f679c07bebbe5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd","sha256":"7f21d7fef55862a50382645a104244928536d274bc7136b5a53dfef03a326a3e","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.root"}],"root":"Coverage.Main.shapes","sha256":"0c98bdd1b5c43f4a39c5ef98c0abc997047ad86f630f9276e3bf795b1928441d","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.root"},{"byte_length":6637,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13","program":{"byte_length":1517,"sha256":"43b6eedb7829b3598a29348c532e07d70295631eb2650df5de98d38c3daccb35"},"renderings":[{"byte_length":7237,"composed":{"byte_length":17051,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd","sha256":"4f10f17f684f23b83e12d9467b1f5469f1bf54036e88759e65b4c5c9a362e1e7","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd.root"},"crate":{"byte_length":13479,"sha256":"92cec27dd560e7ca0a9f5daa440567b51beb597b69ef56f0678a55f0729d1198"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd","sha256":"3f0808374ddb86f7cb931036b058e580dddd14e892bbfad83004e29233186842","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.root"}],"root":"Coverage.Main.treeTotal","sha256":"e1057527317e1ffaa0b259b01bd31534b1571c59ca55a278996ac931def155b7","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.root"},{"byte_length":6646,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14","program":{"byte_length":1628,"sha256":"f6c459c7f8163810d05bc43460cd394578f415d182096e2ad51dae6252d4f656"},"renderings":[{"byte_length":7066,"composed":{"byte_length":23308,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore","sha256":"bf504c627e0e75d84acc81d886aeeb1a21595ae108bf70e6ea201da85eae61ef","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.root"},"crate":{"byte_length":4685,"sha256":"73a3e27a1326d458fa653a2a3b7057649a690cfc50441d306fc0456004f12045"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore","sha256":"5448c7fcf866f8da57a361278141d537b1c3d559f39ee9b588ef9168a5b8e59f","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.root"},{"byte_length":7063,"composed":{"byte_length":23293,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd","sha256":"8ceaeb01b3d1a35b27f8daf24a34261e872eaddd3afdc7a8968e700c51c4c896","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.root"},"crate":{"byte_length":13603,"sha256":"4b8bab9cd36b1b9026cb5992a83d73f087c3a70988458b0e1f559b5e0d15d812"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd","sha256":"8efd91cd37e2eb523985e73399aacfc123de5b031a8ee34f7d367dfad40dd4c0","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.root"}],"root":"Coverage.Main.records","sha256":"c3aac043aac68fdf99843da0ca6296995661d6d975de42ff6a0c58a6d8267cc0","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.root"},{"byte_length":5198,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15","program":{"byte_length":989,"sha256":"1817e8488f6542ec7a9c65ee73a26b9b2ce35ef18dad904d897c9dded6e3cbf9"},"renderings":[{"byte_length":5464,"composed":{"byte_length":18151,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore","sha256":"533365a4b3b0ba6cba1894f87e5b80ff909b3e628a74e46c8afbbe476ce404e2","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore.root"},"crate":{"byte_length":4417,"sha256":"31aa7ca5ef4e02642fd2c913c93293b098b0b55555ebd261df0377b68180139e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore","sha256":"2fba9e0869c454c869ef425d41fe585f3583feab047d12e51ce373b18b094732","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore.root"},{"byte_length":5461,"composed":{"byte_length":18142,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd","sha256":"a79fb19b6a3ff4f9c1520946656654b0d2e7c623eea0692691cf42520b0a7504","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd.root"},"crate":{"byte_length":13335,"sha256":"44fa70d0448251f98e8fdef3403a5990d6a42239304a80f10cb6830960f7268d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd","sha256":"95f3893e6bb0ef1b3da615ba9751c0097466916f259558ffe0a6cca5cc97464a","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd.root"}],"root":"Coverage.Main.options","sha256":"5e56681ac37f6c0da09a87922d5d46962f45772af43d9cd4d6aa7746e364535b","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.root"},{"byte_length":4914,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16","program":{"byte_length":1264,"sha256":"234deee526474348f12566f97e315f4a79becf0607138d82ae06f555a4d3f2db"},"renderings":[{"byte_length":3982,"composed":{"byte_length":12290,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore","sha256":"ef393beb9e26886cfacc0b6216036dc3906592967cc1cabb9c37cb01163bfed3","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore.root"},"crate":{"byte_length":4121,"sha256":"84aab30692ec8281062085a409bfc422cd779958bb5c57ef9e59799a768d2501"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore","sha256":"40ebd3a567efeb207027d035c385801538753d07ad7dcce2ad4574672f674cd7","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore.root"},{"byte_length":3979,"composed":{"byte_length":12281,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd","sha256":"0310ff5905c2605d7932c10038816adb4c3224e83bd7358f26d6e9a76404cb8f","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd.root"},"crate":{"byte_length":13039,"sha256":"6d8bc511c7f98f686d36dbda86f3c9a344a7dcdf69021b28be933128dcaaae78"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd","sha256":"a62758c506548a14dde70849045c47d127af57b15126fd08ec1f79ede7c03bf2","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd.root"}],"root":"Coverage.Main.builders","sha256":"ee60e433bc97680ac58c0b3415e59c5dea3d79c8929f36e166ec34d351bfaded","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.root"},{"byte_length":2718,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17","program":{"byte_length":451,"sha256":"7d925a72d07005baaa5a9371f60e52199072e49139630af3348972394ef0539f"},"renderings":[{"byte_length":2405,"composed":{"byte_length":15180,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore","sha256":"2a5f64399816cfecd3d8f19905163e1ae4056ea3a03fec7226d11117f7e6a0e5","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore.root"},"crate":{"byte_length":4003,"sha256":"9ee584eed11f7b4efb99475c2a6b35939dc35dd3f263806aec3ae84479b96685"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore","sha256":"9f93bed1eac77aaa3ca3bd9a8a7e199705606ff720e40398f1f51ddca5258016","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore.root"},{"byte_length":2402,"composed":{"byte_length":15171,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd","sha256":"fe6ffa20beac72d802263b112bbcb3446091ae6317447799f5972d282adf6554","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd.root"},"crate":{"byte_length":12921,"sha256":"5e115227d6075aa279430638e5ddb6995ac255db0bd608e107a843bd468dde51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd","sha256":"5b51e4fcd5bd2beb0d2f4c4f861ec842658bd49ccf48fac1a39d6a453103209c","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd.root"}],"root":"Coverage.Main.pairs","sha256":"884b9ac3166543a1a480fbb0d99a9f74552a833cdece54ca2ba3bbfa337acbf6","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.root"},{"byte_length":10732,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18","program":{"byte_length":1873,"sha256":"b9a631ceb72fc1536c7c26c88ce17cb71084492929763dc601a2e579e3b15596"},"renderings":[{"byte_length":12456,"composed":{"byte_length":13223,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore","sha256":"dd718b6a677cfa27916c4c03eb765eef18e3ee77193f866ff2b729f21612c2f5","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore.root"},"crate":{"byte_length":5047,"sha256":"2c1e15094b24d3e5c9a0a06315afc8bf4c60341ba27fd1bf252230213141f5fe"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore","sha256":"f0f364a8086fff5df4288f0aca5764991968b85915bcb9834ac5a761933cdd05","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore.root"},{"byte_length":12453,"composed":{"byte_length":13214,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd","sha256":"1c6c1d0034bc25a425de3e6414fc72a49deca9c239963947dcf3dd38b7324b73","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd.root"},"crate":{"byte_length":13965,"sha256":"d46d5bf325126545575bdf8963f16739be5cfb777b38c5233acf8ea8c474a576"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd","sha256":"0836bf8a7de7af1510c422ea43e43a38e19f76d414e244c030b93ddbce0143a6","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd.root"}],"root":"Coverage.Main.higher","sha256":"68d3ebd1e9ce8bd045ebc93eb1634347e7f5e2364f136e00237ec401bf186f84","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.root"},{"byte_length":8621,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19","program":{"byte_length":1884,"sha256":"83625b33701e16e8f1014fd8a942ea0ac67a87cefb2ef0f93321f9dbc4bbe943"},"renderings":[{"byte_length":7953,"composed":{"byte_length":13594,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd","sha256":"f56840774d4df0140611b48dbeadce036755856d995f9ff098deb7e56d930f9e","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd.root"},"crate":{"byte_length":13607,"sha256":"ffd9d2b0d04acb6874cfa5f2983560a9c24a75e8bbd9f3b2580f84d5a76d7b70"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd","sha256":"0a7cc7d94c946e8615f0a55f63353ef660c85832e3e6b5b15bc83548a1d9457a","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd.root"}],"root":"Coverage.Main.mapped","sha256":"1993d9aec62e222d1336a4257cba1111d820811436e6446fbec087e01b986a3b","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.root"},{"byte_length":4983,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20","program":{"byte_length":999,"sha256":"d80d8fa87a73970b99d0429236be199dba9bdbb4207a8c64505ec3f999bc2775"},"renderings":[{"byte_length":4204,"composed":{"byte_length":12086,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore","sha256":"39ea7976beaea4393791c9239839c313c2f39a9b7f8f764f40182537746a1c01","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore.root"},"crate":{"byte_length":4179,"sha256":"fcb23d2bf0050b3ce8c890495631aa62147613e0a92836750e7c5fd2bb3b60dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore","sha256":"c63b83146c15afd118af18a6edf1e6b052d34605720b32d577899d64c25ccaab","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore.root"},{"byte_length":4201,"composed":{"byte_length":12077,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd","sha256":"47f80d2d1a1439b6182377a1d34a7a9ef15f54c44cae4552584ecf5659a4a80b","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd.root"},"crate":{"byte_length":13097,"sha256":"a9de1e3631675db5a707a20a389993cdccd26644956d0ad09e14a25f26b8123f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd","sha256":"992a5cd39d95182550754100ecb06642210af8690474115b5347c57c73b88f2e","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd.root"}],"root":"Coverage.Main.parity","sha256":"58943dcfa3ab52f2bdf3e4148b43213ff5f1142b8141b764642e3ef95fd0cea5","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.root"},{"byte_length":6865,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21","program":{"byte_length":2446,"sha256":"ef7c0ba20d049db4524a6ec6561a20d86bd33230f60e21dc733706135be42f2d"},"renderings":[{"byte_length":7321,"composed":{"byte_length":13587,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore","sha256":"7d1750b3174e5f51a3ff5f5ded398735af6f5e7d09f28af0dc2d38f54d8dc411","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore.root"},"crate":{"byte_length":4385,"sha256":"f4884b32be79ba4577ae148c340ffd389f3ab673bab9b3e0a6151d92a64dac98"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore","sha256":"f1071c942a06fa2989bd7d53d525f1a44675c3ab1104ec1bec0f5ca0608df418","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore.root"},{"byte_length":7318,"composed":{"byte_length":13578,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd","sha256":"9bdc90451acd6f95f0747fcb212742cbc5076891d76128386787e8c61ef014d9","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd.root"},"crate":{"byte_length":13303,"sha256":"a09d0b574d6829f8ce94552a82e7770388c891bf3591aef3bdb2aa1c80734465"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd","sha256":"b56adc091e4cd71d045e3c70e5a8d248c47406185bc3de8e9f63e6ab0ff92a2f","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd.root"}],"root":"Coverage.Prims.fixedSmall","sha256":"07946fec25c51d667c09f243b7157adca2f414d2676616da4a0aead5619867d9","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.root"},{"byte_length":5605,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22","program":{"byte_length":1770,"sha256":"c5c4a8ee12a3a426500bb6c4e82af761e1af447511bd597e1bc5dce63970ddaf"},"renderings":[{"byte_length":5884,"composed":{"byte_length":14419,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore","sha256":"8689de15a849fafe326eaa13194f837611ceeb1ab4ae8b50265d4b8347e979f4","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore.root"},"crate":{"byte_length":4285,"sha256":"9ad73a749e8c19c7038a85d6fd571a10e3024158934cfc17d738099d4257e7c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore","sha256":"a40b3b67713565517cd7eb9433b0be2b0dade8c72351038bee39b798614356f4","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore.root"},{"byte_length":5881,"composed":{"byte_length":14410,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd","sha256":"1ff8668deb2167bf23c9ddca2eae21ebf4c34e6c1800509726fd840846e0cd15","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd.root"},"crate":{"byte_length":13203,"sha256":"2e31d2ad0160635ba75b00c7c15bc08e71de244c902defb8fddb06175c8752e4"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd","sha256":"a083cf7b7887c7e14b78bcdac2430aff96cb49526e743ec48fa3aecbce9c71a1","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd.root"}],"root":"Coverage.Prims.fixedMiddle","sha256":"c964b94b1f222773f1aada17af571aeb5a59e7aec55e30a98e00f80bfbba00e6","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.root"},{"byte_length":8520,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23","program":{"byte_length":3324,"sha256":"046e9276a504b885d2582f97b9c4fb34281d09496a6f649c6c147f6361e56c8d"},"renderings":[{"byte_length":8909,"composed":{"byte_length":15652,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore","sha256":"9a22160006bdde97b8a2bf43e42cf7be5a812c11c34204c1399cbd507e202b7b","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore.root"},"crate":{"byte_length":4519,"sha256":"e68ee92c192814f24ef49f678d7b0f10e590262eaac0e5a5edafd2716711b54f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore","sha256":"d1ebf2579e50cd471af7d2eb3bde9acac9c3260d885e35a2a3ed2f8e2580bd98","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore.root"},{"byte_length":8906,"composed":{"byte_length":15643,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd","sha256":"c8cda5895d87c842696e54125c09a24c054cae8631855f6bba2304a01b32f169","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd.root"},"crate":{"byte_length":13437,"sha256":"2f8e04183e437e3b85961d1277fa70eec93662dd97eb0e6e4f0d1d1adfc95798"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd","sha256":"2af8ef16e05d2455c638a487e1d4b73c4817f098684dba99ebf37566da30d106","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd.root"}],"root":"Coverage.Prims.fixedWide","sha256":"bc47ef5c49501fa1efbe86502b850b017370f06a5f52ea6906baed55dd22f54e","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.root"},{"byte_length":8690,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24","program":{"byte_length":3494,"sha256":"9ed3cf1ba1de6ddfd0c865acea0ee413b21ac44fb1d556e8eac704b552c3d018"},"renderings":[{"byte_length":9917,"composed":{"byte_length":15730,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore","sha256":"b315fd81b7ff60250315ec558402dcfb442ca56c235d5ccc4ac48d355dc22384","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore.root"},"crate":{"byte_length":4562,"sha256":"f594bce05710d6a44ba4db5022a8759b6ac698bed7b389b7e60d820c93373a21"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore","sha256":"86c68cf1725cbee72359b2bb72275c234bdfc2c8a3aeb31f266124d04b798487","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore.root"},{"byte_length":9914,"composed":{"byte_length":15721,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd","sha256":"55b252ca2666f52c3ee46fafc3982f28fccdabec534a6dedefcc62eade0d2c04","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd.root"},"crate":{"byte_length":13480,"sha256":"34ed06527b7da3dc36936034ff6c7a0145675fd668c22ed6feafa9a3b418e3bf"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd","sha256":"9f17e18541cc6e479bb37fd57b170dc3a1c2e7b1069aedba30acc7db3ca61007","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd.root"}],"root":"Coverage.Prims.bits","sha256":"09465c147273246c491c6b919c4703e42989b3fb4480b92baff2cf7540ca4bca","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.root"},{"byte_length":3336,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25","program":{"byte_length":701,"sha256":"6227207e0bebaa6609e8bfedfaffb83e7fcb5e8c11d9ed9caaa35fb65b35766f"},"renderings":[{"byte_length":2932,"composed":{"byte_length":14299,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore","sha256":"a86b2a697741a6c2803ea2a377bc9060787086b5127fff8fbe7e96bd508cd26e","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore.root"},"crate":{"byte_length":4072,"sha256":"177164e24d17c1a066fd7038902d01c1f8dfd73c69ed8377af3b1c2db5cc1412"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore","sha256":"0f402e373332ae85a115781d4e9e2582f263aa30cf71b554ca73d0eb623472a7","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore.root"},{"byte_length":2929,"composed":{"byte_length":14290,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd","sha256":"3b3559be9589a18b0e71970588fb497f368e79f2ff9786be92ef3a95b6af9d2e","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd.root"},"crate":{"byte_length":12990,"sha256":"2f5c6ff9563847b0e68f1b9b206d825a78c81a047a954fd54ab509b3bd79de61"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd","sha256":"048faad3c13980a53edbc0f89e15a643430897621d4c56326cc6b83e9839e9c8","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd.root"}],"root":"Coverage.Prims.conversions","sha256":"a79055932efffcf929c88bc91b7d2d85c9ed2ced2b3b05b5c422793a6bd1d140","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.root"},{"byte_length":14059,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26","program":{"byte_length":5637,"sha256":"c01fc096fdf4c89e91adb6928197ce32bcb7e42426af0487546f4edc98fd3702"},"renderings":[{"byte_length":16373,"composed":{"byte_length":17651,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd","sha256":"4168db24faefab6ccc33a927d01ef4e7499fbb43f0c2e5123b6066c43857a5a3","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd.root"},"crate":{"byte_length":14078,"sha256":"64aebfe2ed7b706cea90fb4e7ee5b7630cb43e480aa43f74e6fe9af4c4142601"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd","sha256":"89fbea3cee495254e7347ebe6988ec09bbf5d808039940c8094cd2915ebd2896","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd.root"}],"root":"Coverage.Prims.sequences","sha256":"0bd5e9affa68f94728bf2ff2a621b60833a106c3d5239020f765f7c386ce65b2","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.root"},{"byte_length":3214,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27","program":{"byte_length":686,"sha256":"6fc888e3f1e9cf5a37f9f68cc01d1a1ff94cc30a552b384155cb811a9d13a526"},"renderings":[{"byte_length":2818,"composed":{"byte_length":12362,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd","sha256":"e41b8817a8ac64f3e85f8e854498cc80ba631f25c5fab6eb6ad7746e5b667630","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd.root"},"crate":{"byte_length":12956,"sha256":"11b389208a11b50ffd36526d42d3b92b00669a700b8875d53bef97f92efd7c8a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd","sha256":"c3b055b7a3382a0898fce7f736aca5bd5c9fa966c14c896d5d255dc8034e8e3c","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd.root"}],"root":"Coverage.Prims.decimals","sha256":"f7f7f28872c2a8d9889d8ca8ff542269a29642e82ebffb154dea121680fc1a29","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.root"},{"byte_length":3046,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28","program":{"byte_length":529,"sha256":"a2d6d8d674af0354e10f236b2b6dcab2579a6ff9db94b3a696fb2c0679df7372"},"renderings":[{"byte_length":2791,"composed":{"byte_length":14110,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd","sha256":"81e5d6e7b7e736fbbb47c79677536f85bf8904140c4936aa7491463c68a496ff","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd.root"},"crate":{"byte_length":12933,"sha256":"d0b018bf12ebfd193d45370c9a299fe8448a30481f706e8bcf5a756c78b6359e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd","sha256":"fcefb2ac0c0666a3997f9527f64a583bd1e550983d1c7cc1f31dc1369c981672","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd.root"}],"root":"Coverage.Prims.formats","sha256":"12359f0159434ecfdcf4ba04f033866b5a72832f06b61c2417e50c437bf55bc4","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.root"},{"byte_length":11694,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29","program":{"byte_length":4118,"sha256":"54080023d9f656975c8d23e285159c2f80184d9c38941ebdeb9b115207eaea0f"},"renderings":[{"byte_length":14927,"composed":{"byte_length":13973,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd","sha256":"fa67b4f24c755e838bc2fb30b425c5d4210a5a5055beca919f45d8faa14e1594","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd.root"},"crate":{"byte_length":13981,"sha256":"e4aba3ad1a43ca155a88aec769bcc47479e9e5091944214f2a469ca7b68e7d9c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd","sha256":"2c4c5160d758f11b1f7dec18c1520cc0f7536c37744e504c84cad05924f75a27","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd.root"}],"root":"Coverage.Prims.text","sha256":"9d762bb3183931a74cc8f4c240b22b9dc5c5664b3ee02d3ecdffef8f527bb9ec","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.root"},{"byte_length":8119,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30","program":{"byte_length":1887,"sha256":"023b87970dcc71c4e8be45aa676e75b9db5753e3da5f8ac416891d595dca8b41"},"renderings":[{"byte_length":7705,"composed":{"byte_length":19612,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd","sha256":"43e52c215bbdbc23aa6aede8305dc9c443b7cd059ad7cecee316abd41b6076e9","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.root"},"crate":{"byte_length":13423,"sha256":"7b6d66e610ef88eda88943c88c3322a2c1bf519e41049d16afe53d039cd7033a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd","sha256":"e25f62db5dbc7a6b49f1001ed8c96462d379afde7a161bcdad95222128f7c531","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.root"}],"root":"Coverage.RecRoots.roseTotal","sha256":"448333ca274e3ff20bd3547e96cbcbbb840de4c7c4aa7b681ed2c81ebc4e83a5","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.root"},{"byte_length":12655,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31","program":{"byte_length":2687,"sha256":"0b283960a85e885aef98cffde5a37a5840fe6905cb960332eb57755a9f588e7b"},"renderings":[{"byte_length":15589,"composed":{"byte_length":27393,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd","sha256":"9bf6b4a94bfbb7e17bd6d3aeac0b651f6affa5c7fefe4dadaf130f38d1b8e79e","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.root"},"crate":{"byte_length":14339,"sha256":"3c3d755be5666a0def8f507f530fa6c1b75ce74ae299363b69cdd7f19b598674"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd","sha256":"52211fc39045577478484827fe2ffd6420834befbb418ecc7d2c2787ad9c36e9","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.root"}],"root":"Coverage.RecRoots.syntaxTotal","sha256":"a5ab58f17283c3e4b9c0738fd2530ec91bb600a34e7ed66c89b4b41fb701756d","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.root"},{"byte_length":17232,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32","program":{"byte_length":3120,"sha256":"a30548452b5811cfc83abdc547d7e93bbdfaf6ae193442225eed19b212b84e5d"},"renderings":[{"byte_length":19234,"composed":{"byte_length":13329,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore","sha256":"a517a1af3f350d1c926aef6a3f7cd20dfc2dde7eaa8a3048c9bb5f566fb7ef13","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore.root"},"crate":{"byte_length":5179,"sha256":"595b9659cce79629fb199be239edeba9f908e19c5863ec7fc71ddbea1ca6b16d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore","sha256":"299a8e60e31250a605d9157a3bc705bacc36f9f4d818ab831cdcc850693ac089","target":"rust-core","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore.root"},{"byte_length":19231,"composed":{"byte_length":13320,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd","sha256":"07e49b0f560730c133d077e9d0e918f81aa5539d71435e2d09d984a91b2f8c6c","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd.root"},"crate":{"byte_length":14097,"sha256":"5bde24114f0f63beca1277bf6cd06ea203bd89352590534d5844f6639bbeb943"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd","sha256":"025789ce61c2fb28f6d19b5475f235681a08f19fbb2ea4e68ce0e12939c38de5","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd.root"}],"root":"Coverage.RecRoots.wellFounded","sha256":"179e94c9f3f93fa7a686a4d42a5e3f12a42d8f94c4ed8f2b5a33649ef89d87fe","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.root"},{"byte_length":15632,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33","program":{"byte_length":2757,"sha256":"696084d3a568dde72c41261e20eb3e6dfc3055d9f56ddb2a9980a5b1eb061f89"},"renderings":[{"byte_length":13569,"composed":{"byte_length":16990,"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd","sha256":"f03997e4b075524628874fb403e4a2553c2a577c46f883d6e259229987404a70","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.root"},"crate":{"byte_length":14222,"sha256":"85ddef0fbc268b258386fd1d552610372cf646edbeda718288d5bc4554a58de0"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd","sha256":"c9346b2d91265923067b800cb139432d9a262e343bc900cc75edbb3c3361942a","target":"rust-std","theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.root"}],"root":"Coverage.RecRoots.rewrite","sha256":"886c89f5c5879c15c48f3ea5c5a77888885cbd96f01e568a9e63a23eca851137","targets":["rust-std"],"theorem":"LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.root"}],"spec":"lexlean/preservation/1"} diff --git a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Audit.json index ab927ac35..80e77aa93 100644 --- a/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Audit.json +++ b/examples/production-coverage/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"221c19fe489d70fefb4c8dba2d3c2ee30e06d706b1efcfac42835a8b71159427","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R9.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R10.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R11.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R15.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R16.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R17.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R18.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R19.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R20.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R21.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R22.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R23.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R24.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R25.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R26.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R27.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R28.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R29.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R32.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_1' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtItems_3' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_4' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wtAux_2' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R0.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R12.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R13.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R14.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R30.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R31.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"e5d164c25b9dc30e2c9f904d9f23172120f4d9856599136410dfa7513e208162","tool":"lean"} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustCore.lean deleted file mode 100644 index 347335f91..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0 -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (left : UInt32) (right : UInt32) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.u32 left), (_root_.LexLeanTarget.TargetSyntax.Value.u32 right)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.denote left right) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.u32 left), (_root_.LexLeanTarget.TargetSyntax.Value.u32 right)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u32 left) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u32 right) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.root left right) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustCore.lex.tex new file mode 100644 index 000000000..254a51733 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustCore.lex.tex @@ -0,0 +1,464 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0, + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore.root : @920 := @921 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore.program +@1 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore.krate +@2 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore.flags +@3 := UInt32 +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.u32 +@6 := @5 @4 +@9 := LexLeanTarget.TargetSyntax.Ty.fixed LexLeanTarget.TargetSyntax.IntKind.u32 +@10 := LexLeanTarget.TargetSyntax.Program +@11 := LexLeanPreservation.Rust.RCrate +@12 := LexLeanPreservation.Rust.Flags +@13 := LexLeanPreservation.Rust.WT +@14 := #3 +@16 := @13 @14 @4 +@17 := #1 +@18 := @16 @17 +@19 := #0 +@20 := @5 @19 +@26 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @3) -> @18 @20 @9 +@28 := LexLeanPreservation.Rust.wt_u32 @0 +@29 := @13 @0 +@36 := {c : @11} -> {A : @12} -> (x : @3) -> @29 @4 @17 @20 @9 +@37 := @28 @1 +@38 := @29 @1 +@43 := {A : @12} -> (x : @3) -> @38 @17 @20 @9 +@44 := @37 @2 +@45 := @38 @2 +@48 := (x : @3) -> @45 @20 @9 +@49 := @44 @4 +@51 := @45 @6 @9 +@52 := @5 @17 +@53 := @44 @17 +@55 := @45 @52 @9 +@56 := LexLeanTarget.TargetSyntax.Value +@57 := List.nil.{0} +@58 := List.cons.{0} +@59 := @57 @56 +@60 := @58 @56 +@61 := @60 @52 +@62 := @61 @59 +@63 := @60 @6 +@64 := @63 @62 +@65 := Nat +@68 := Prod.{0, 0} @65 @56 +@69 := 1 +@72 := Prod.mk.{0, 0} @65 @56 +@73 := @72 @69 +@74 := @73 @52 +@75 := 0 +@76 := @72 @75 +@77 := @76 @6 +@78 := @57 @68 +@79 := @58 @68 +@81 := @79 @77 @78 +@83 := @79 @74 @81 +@84 := Bool.false +@85 := LexLeanTarget.TargetSyntax.Function +@86 := LexLeanTarget.TargetSyntax.Program.functions +@87 := @86 @0 +@88 := LexLeanTarget.TargetSyntax.Ty +@89 := @57 @65 +@90 := @57 @88 +@91 := LexLeanTarget.TargetSyntax.Ty.unit +@92 := LexLeanTarget.TargetSyntax.Value.unit +@95 := LexLeanTarget.TargetSyntax.Expr.value @91 @92 +@100 := LexLeanTarget.TargetSyntax.Function.mk @89 @90 @91 @95 +@105 := List.getD.{0} @85 @87 @75 @100 +@109 := fun (__e_n : @65) => + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore.root @19 @75 +@110 := LexLeanPreservation.Rust.WTL +@118 := {p : @10} -> {c : @11} -> {A : @12} -> @110 @4 @17 @19 @59 @90 +@120 := LexLeanPreservation.Rust.wtl_nil @0 +@121 := @110 @0 +@127 := {c : @11} -> {A : @12} -> @121 @17 @19 @59 @90 +@128 := @120 @1 +@129 := @121 @1 +@133 := {A : @12} -> @129 @19 @59 @90 +@134 := @128 @2 +@135 := @129 @2 +@136 := @135 @59 +@137 := @136 @90 +@138 := List.{0} +@139 := @138 @56 +@140 := @138 @88 +@141 := #6 +@142 := @13 @141 +@143 := #5 +@144 := @142 @143 +@145 := #4 +@148 := @144 @145 @14 @4 +@149 := #7 +@154 := @110 @149 @141 @143 @4 @17 +@155 := #8 +@158 := @110 @155 @149 @141 +@160 := @60 @143 @14 +@161 := @158 @160 +@162 := @58 @88 +@164 := @162 @145 @4 +@174 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {v : @56} -> {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @148) -> (hs : @154) -> @161 @164 +@176 := LexLeanPreservation.Rust.wtl_cons @0 +@196 := {c : @11} -> + {A : @12} -> + {v : @56} -> + {t : @88} -> + {vs : @139} -> + {ts : @140} -> + (h : @29 @143 @145 @14 @4) -> (hs : @121 @141 @143 @4 @17) -> @121 @149 @141 @160 @164 +@197 := @176 @1 +@213 := {A : @12} -> + {v : @56} -> + {t : @88} -> + {vs : @139} -> + {ts : @140} -> (h : @38 @145 @14 @4) -> (hs : @129 @143 @4 @17) -> @129 @141 @160 @164 +@214 := @197 @2 +@216 := @45 @14 @4 +@218 := @135 @4 @17 +@226 := {v : @56} -> + {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @216) -> (hs : @218) -> @135 @160 @164 +@227 := @214 @52 +@228 := @5 @145 +@229 := @45 @228 +@230 := @229 @4 +@231 := @5 @141 +@232 := @60 @231 +@234 := @135 (@232 @14) +@240 := {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @230) -> (hs : @218) -> @234 @164 +@241 := @227 @9 +@242 := @5 @14 +@244 := @45 @242 @9 +@245 := @5 @143 +@246 := @60 @245 +@248 := @135 (@246 @14) +@249 := @162 @9 +@250 := @249 @4 +@255 := {vs : @139} -> {ts : @140} -> (h : @244) -> (hs : @218) -> @248 @250 +@256 := @241 @59 +@257 := @136 @17 +@258 := @60 @228 +@259 := @258 @59 +@264 := {ts : @140} -> (h : @51) -> (hs : @257) -> @135 @259 @250 +@265 := @256 @90 +@266 := @60 @242 +@267 := @266 @59 +@268 := @135 @267 +@269 := @249 @90 +@272 := (h : @55) -> (hs : @137) -> @268 @269 +@273 := @265 @53 +@274 := @63 @59 +@276 := @135 @274 @269 +@277 := (hs : @137) -> @276 +@278 := @273 @134 +@280 := @135 @62 @269 +@281 := @214 @6 +@283 := @45 @245 @4 +@284 := @5 @149 +@285 := @60 @284 +@293 := {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @283) -> (hs : @218) -> @135 (@285 @14) @164 +@294 := @281 @9 +@300 := {vs : @139} -> {ts : @140} -> (h : @229 @9) -> (hs : @218) -> @234 @250 +@301 := @294 @62 +@302 := @268 @17 +@303 := @246 @259 +@304 := @135 @303 +@308 := {ts : @140} -> (h : @244) -> (hs : @302) -> @304 @250 +@309 := @301 @269 +@310 := @258 @267 +@311 := @135 @310 +@312 := @249 @269 +@315 := (h : @51) -> (hs : @276) -> @311 @312 +@316 := @309 @49 +@317 := @266 @274 +@318 := @135 @317 +@320 := (hs : @280) -> @318 @312 +@321 := @316 @278 +@322 := @135 @64 +@323 := @322 @312 +@324 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.denote +@326 := @324 @4 @17 +@327 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.__fits_0 +@329 := @327 @4 @17 +@332 := Production.Main.checkedSum @4 @17 +@336 := LexLeanPreservation.encOption @3 @5 @332 +@339 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.root @4 @17 +@340 := Bool +@341 := Ne.{1} +@342 := LexLeanPreservation.Obs +@343 := @341 @342 +@344 := LexLeanPreservation.Rel +@347 := @343 (@344 @17 @19) +@348 := LexLeanPreservation.Obs.stuck +@351 := (f : @340) -> (v : @56) -> @347 @348 +@353 := LexLeanPreservation.Rust.rel_ne_stuck @329 +@360 := (v : @56) -> @343 (@344 (@327 @14 @4) @19) @348 +@361 := @353 @336 +@365 := @343 (@344 @329 @336) @348 +@366 := @138 @68 +@367 := LexLeanPreservation.Rust.FunSem +@368 := #9 +@374 := (n : @65) -> @367 @368 @155 @149 @19 @141 +@375 := Eq.{1} +@376 := Option.{0} +@377 := @376 @85 +@378 := @375 @377 +@385 := LexLeanRuntime.index (@138 @85) @85 (LexLeanRuntime.instIndexableList @85) +@389 := @378 (@385 (@86 @368) @141) +@390 := Option.some.{0} +@391 := @390 @85 +@392 := @391 @143 +@393 := @389 @392 +@394 := #10 +@398 := @110 @394 @368 @155 @143 +@399 := LexLeanTarget.TargetSyntax.Function.types +@400 := @399 @141 +@401 := @398 @400 +@402 := @376 @366 +@403 := @375 @402 +@404 := LexLeanTarget.TargetSemantics.bindAll +@405 := LexLeanTarget.TargetSyntax.Function.parameters +@410 := @403 (@404 (@405 @149) @141 @78) +@411 := @390 @366 +@412 := @411 @143 +@413 := @410 @412 +@414 := @376 @340 +@415 := @375 @414 +@416 := LexLeanPreservation.Rust.fnFallible +@417 := #11 +@420 := @415 (@416 @417 @368) +@421 := @390 @340 +@422 := @421 @143 +@423 := @420 @422 +@424 := LexLeanPreservation.RunConv +@425 := #13 +@429 := @424 @425 @394 @155 @143 +@431 := @343 @141 @348 +@432 := Exists.{1} +@433 := LexLeanPreservation.Rust.ROut +@434 := @432 @433 +@435 := And +@436 := LexLeanPreservation.Rust.RealizesFn +@440 := @435 (@436 @368 @155 @19) +@441 := LexLeanPreservation.Rust.RCI +@443 := @441 #15 +@444 := LexLeanPreservation.Rust.fnIdent +@445 := @444 @425 +@452 := (hne : @431) -> @434 (fun (ro : @433) => @440 (@443 @445 @417 @19)) +@467 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @366} -> + {F : @340} -> + {o : @342} -> + (hB : @374) -> + (hfn : @393) -> (hwt : @401) -> (hbind : @413) -> (hF : @423) -> (hA : @429) -> @452 +@469 := LexLeanPreservation.Rust.compose @0 +@470 := @367 @0 +@475 := (n : @65) -> @470 @155 @149 @19 @141 +@476 := @385 @87 +@479 := @378 (@476 @141) @392 +@483 := @121 @368 @155 @143 @400 +@484 := @424 @0 +@487 := @484 @394 @155 @143 +@501 := {c : @11} -> + {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @366} -> + {F : @340} -> + {o : @342} -> + (hB : @475) -> + (hfn : @479) -> (hwt : @483) -> (hbind : @413) -> (hF : @423) -> (hA : @487) -> @452 +@502 := @469 @1 +@503 := @470 @1 +@507 := (n : @65) -> @503 @149 @19 @141 +@510 := @129 @155 @143 @400 +@511 := @416 @1 +@514 := @415 (@511 @368) @422 +@515 := @441 @1 +@525 := (hbind : @413) -> + (hF : @514) -> (hA : @487) -> (hne : @431) -> @434 (fun (ro : @433) => @440 (@515 @445 @417 @19)) +@535 := {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @366} -> {F : @340} -> {o : @342} -> (hB : @507) -> (hfn : @479) -> (hwt : @510) -> @525 +@536 := @502 @2 +@538 := @503 @2 @19 +@540 := (n : @65) -> @538 @141 +@541 := @135 @143 +@542 := @541 @400 +@551 := {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @366} -> {F : @340} -> {o : @342} -> (hB : @540) -> (hfn : @479) -> (hwt : @542) -> @525 +@552 := @536 @75 +@554 := (n : @65) -> @538 @75 +@555 := @476 @75 +@556 := @378 @555 +@557 := @556 @392 +@558 := @511 @75 +@559 := @415 @558 +@560 := @559 @422 +@561 := @484 @75 +@563 := @561 @155 @143 +@565 := @515 (@444 @75) +@573 := (hF : @560) -> (hA : @563) -> (hne : @431) -> @434 (fun (ro : @433) => @440 (@565 @417 @19)) +@582 := {fn : @85} -> + {args : @139} -> + {env : @366} -> + {F : @340} -> {o : @342} -> (hB : @554) -> (hfn : @557) -> (hwt : @542) -> (hbind : @413) -> @573 +@583 := @552 @105 +@585 := @556 (@391 @105) +@586 := @399 @105 +@587 := @541 @586 +@589 := @404 (@405 @105) +@601 := {args : @139} -> + {env : @366} -> + {F : @340} -> + {o : @342} -> + (hB : @554) -> (hfn : @585) -> (hwt : @587) -> (hbind : @403 (@589 @141 @78) @412) -> @573 +@602 := @583 @64 +@604 := @285 (@232 @59) +@606 := @135 @604 @586 +@608 := @60 (@5 @155) +@610 := @608 (@285 @59) +@614 := @403 (@589 @610 @78) @412 +@616 := @60 (@5 @394) +@618 := @60 (@5 @368) +@620 := @616 (@618 @59) +@622 := @561 @620 @143 +@624 := @60 (@5 @425) +@627 := @60 (@5 #12) +@644 := {env : @366} -> + {F : @340} -> + {o : @342} -> + (hB : @554) -> + (hfn : @585) -> + (hwt : @606) -> + (hbind : @614) -> + (hF : @560) -> + (hA : @622) -> (hne : @431) -> @434 (fun (ro : @433) => @440 (@565 (@624 (@627 @59)) @19)) +@645 := @602 @83 +@647 := @232 (@246 @59) +@649 := @135 @647 @586 +@660 := @403 (@589 @604 @78) (@411 (@79 (@73 @231) (@79 (@76 @284) @78))) +@662 := @618 (@608 @59) +@664 := @561 @662 @143 +@666 := @60 (@5 @417) +@682 := {F : @340} -> + {o : @342} -> + (hB : @554) -> + (hfn : @585) -> + (hwt : @649) -> + (hbind : @660) -> + (hF : @560) -> + (hA : @664) -> (hne : @431) -> @434 (fun (ro : @433) => @440 (@565 (@627 (@666 @59)) @19)) +@683 := @645 @84 +@684 := @304 @586 +@695 := @403 (@589 @647 @78) (@411 (@79 (@73 @245) (@79 (@76 @231) @78))) +@697 := @559 (@421 @84) +@699 := @561 @610 @143 +@700 := @436 @84 +@718 := {o : @342} -> + (hB : @554) -> + (hfn : @585) -> + (hwt : @684) -> + (hbind : @695) -> + (hF : @697) -> + (hA : @699) -> + (hne : @431) -> @434 (fun (ro : @433) => @435 (@700 @155 @19) (@565 (@666 (@616 @59)) @19)) +@719 := @683 @326 +@720 := @311 @586 +@731 := @403 (@589 @303 @78) (@411 (@79 (@73 @228) (@79 (@76 @245) @78))) +@732 := @561 @604 +@734 := @324 @149 @141 +@735 := @732 @734 +@737 := @324 @155 @149 +@756 := (hB : @554) -> + (hfn : @585) -> + (hwt : @720) -> + (hbind : @731) -> + (hF : @697) -> + (hA : @735) -> + (hne : @343 @737 @348) -> + @434 (fun (ro : @433) => @435 (@700 (@324 @394 @368) @19) (@565 @620 @19)) +@757 := @719 @109 +@758 := @318 @586 +@769 := @403 (@589 @310 @78) (@411 (@79 (@73 @242) (@79 (@76 @228) @78))) +@770 := @561 @647 +@772 := @324 @141 @143 +@791 := (hfn : @585) -> + (hwt : @758) -> + (hbind : @769) -> + (hF : @697) -> + (hA : @770 @772) -> + (hne : @343 @734 @348) -> + @434 (fun (ro : @433) => @435 (@700 (@324 @368 @155) @19) (@565 @662 @19)) +@792 := Eq.refl.{1} +@795 := @757 (@792 @377 @555) +@796 := @322 @586 +@807 := @403 (@589 @317 @78) (@411 (@79 (@73 @6) (@79 (@76 @242) @78))) +@808 := @561 @303 +@810 := @324 @143 @145 +@826 := (hwt : @796) -> + (hbind : @807) -> + (hF : @697) -> + (hA : @808 @810) -> + (hne : @343 @772 @348) -> @434 (fun (ro : @433) => @435 (@700 @737 @19) (@565 @610 @19)) +@827 := @795 @321 +@829 := @589 @64 @78 +@832 := @403 @829 (@411 @83) +@833 := @561 @310 +@835 := @324 @145 @14 +@850 := (hbind : @832) -> + (hF : @697) -> + (hA : @833 @835) -> + (hne : @343 @810 @348) -> @434 (fun (ro : @433) => @435 (@700 @734 @19) (@565 @604 @19)) +@853 := @827 (@792 @402 @829) +@854 := @561 @317 +@856 := @324 @14 @4 +@870 := (hF : @697) -> + (hA : @854 @856) -> + (hne : @343 @835 @348) -> @434 (fun (ro : @433) => @435 (@700 @772 @19) (@565 @647 @19)) +@873 := @853 (@792 @414 @558) +@887 := (hA : @561 @64 @326) -> + (hne : @343 @856 @348) -> @434 (fun (ro : @433) => @435 (@700 @810 @19) (@565 @303 @19)) +@888 := @873 @339 +@899 := (hne : @343 @326 @348) -> @434 (fun (ro : @433) => @435 (@700 @835 @19) (@565 @310 @19)) +@900 := @888 @361 +@906 := @435 (@700 @856 @19) (@565 @317 @19) +@908 := @434 (fun (ro : @433) => @906) +@910 := @434 (fun (__e_ro : @433) => @906) +@915 := LexLeanPreservation.Rust.RepresentableL (@61 (@60 @20 @59)) +@916 := (__e_hrep : @915) -> @910 +@917 := fun (__e_hrep : @915) => @900 +@918 := (right : @3) -> @916 +@919 := fun (right : @3) => @917 +@920 := (left : @3) -> @918 +@921 := fun (left : @3) => @919 +\end{coremodule} +\end{lexlean} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustStd.lean deleted file mode 100644 index 8ead0e0ca..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0 -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (left : UInt32) (right : UInt32) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.u32 left), (_root_.LexLeanTarget.TargetSyntax.Value.u32 right)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.denote left right) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.u32 left), (_root_.LexLeanTarget.TargetSyntax.Value.u32 right)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u32 left) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_u32 right) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.root left right) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustStd.lex.tex new file mode 100644 index 000000000..fb5f45bf6 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustStd.lex.tex @@ -0,0 +1,464 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0, + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd.root : @920 := @921 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd.program +@1 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd.krate +@2 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd.flags +@3 := UInt32 +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.u32 +@6 := @5 @4 +@9 := LexLeanTarget.TargetSyntax.Ty.fixed LexLeanTarget.TargetSyntax.IntKind.u32 +@10 := LexLeanTarget.TargetSyntax.Program +@11 := LexLeanPreservation.Rust.RCrate +@12 := LexLeanPreservation.Rust.Flags +@13 := LexLeanPreservation.Rust.WT +@14 := #3 +@16 := @13 @14 @4 +@17 := #1 +@18 := @16 @17 +@19 := #0 +@20 := @5 @19 +@26 := {p : @10} -> {c : @11} -> {A : @12} -> (x : @3) -> @18 @20 @9 +@28 := LexLeanPreservation.Rust.wt_u32 @0 +@29 := @13 @0 +@36 := {c : @11} -> {A : @12} -> (x : @3) -> @29 @4 @17 @20 @9 +@37 := @28 @1 +@38 := @29 @1 +@43 := {A : @12} -> (x : @3) -> @38 @17 @20 @9 +@44 := @37 @2 +@45 := @38 @2 +@48 := (x : @3) -> @45 @20 @9 +@49 := @44 @4 +@51 := @45 @6 @9 +@52 := @5 @17 +@53 := @44 @17 +@55 := @45 @52 @9 +@56 := LexLeanTarget.TargetSyntax.Value +@57 := List.nil.{0} +@58 := List.cons.{0} +@59 := @57 @56 +@60 := @58 @56 +@61 := @60 @52 +@62 := @61 @59 +@63 := @60 @6 +@64 := @63 @62 +@65 := Nat +@68 := Prod.{0, 0} @65 @56 +@69 := 1 +@72 := Prod.mk.{0, 0} @65 @56 +@73 := @72 @69 +@74 := @73 @52 +@75 := 0 +@76 := @72 @75 +@77 := @76 @6 +@78 := @57 @68 +@79 := @58 @68 +@81 := @79 @77 @78 +@83 := @79 @74 @81 +@84 := Bool.false +@85 := LexLeanTarget.TargetSyntax.Function +@86 := LexLeanTarget.TargetSyntax.Program.functions +@87 := @86 @0 +@88 := LexLeanTarget.TargetSyntax.Ty +@89 := @57 @65 +@90 := @57 @88 +@91 := LexLeanTarget.TargetSyntax.Ty.unit +@92 := LexLeanTarget.TargetSyntax.Value.unit +@95 := LexLeanTarget.TargetSyntax.Expr.value @91 @92 +@100 := LexLeanTarget.TargetSyntax.Function.mk @89 @90 @91 @95 +@105 := List.getD.{0} @85 @87 @75 @100 +@109 := fun (__e_n : @65) => + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd.root @19 @75 +@110 := LexLeanPreservation.Rust.WTL +@118 := {p : @10} -> {c : @11} -> {A : @12} -> @110 @4 @17 @19 @59 @90 +@120 := LexLeanPreservation.Rust.wtl_nil @0 +@121 := @110 @0 +@127 := {c : @11} -> {A : @12} -> @121 @17 @19 @59 @90 +@128 := @120 @1 +@129 := @121 @1 +@133 := {A : @12} -> @129 @19 @59 @90 +@134 := @128 @2 +@135 := @129 @2 +@136 := @135 @59 +@137 := @136 @90 +@138 := List.{0} +@139 := @138 @56 +@140 := @138 @88 +@141 := #6 +@142 := @13 @141 +@143 := #5 +@144 := @142 @143 +@145 := #4 +@148 := @144 @145 @14 @4 +@149 := #7 +@154 := @110 @149 @141 @143 @4 @17 +@155 := #8 +@158 := @110 @155 @149 @141 +@160 := @60 @143 @14 +@161 := @158 @160 +@162 := @58 @88 +@164 := @162 @145 @4 +@174 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {v : @56} -> {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @148) -> (hs : @154) -> @161 @164 +@176 := LexLeanPreservation.Rust.wtl_cons @0 +@196 := {c : @11} -> + {A : @12} -> + {v : @56} -> + {t : @88} -> + {vs : @139} -> + {ts : @140} -> + (h : @29 @143 @145 @14 @4) -> (hs : @121 @141 @143 @4 @17) -> @121 @149 @141 @160 @164 +@197 := @176 @1 +@213 := {A : @12} -> + {v : @56} -> + {t : @88} -> + {vs : @139} -> + {ts : @140} -> (h : @38 @145 @14 @4) -> (hs : @129 @143 @4 @17) -> @129 @141 @160 @164 +@214 := @197 @2 +@216 := @45 @14 @4 +@218 := @135 @4 @17 +@226 := {v : @56} -> + {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @216) -> (hs : @218) -> @135 @160 @164 +@227 := @214 @52 +@228 := @5 @145 +@229 := @45 @228 +@230 := @229 @4 +@231 := @5 @141 +@232 := @60 @231 +@234 := @135 (@232 @14) +@240 := {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @230) -> (hs : @218) -> @234 @164 +@241 := @227 @9 +@242 := @5 @14 +@244 := @45 @242 @9 +@245 := @5 @143 +@246 := @60 @245 +@248 := @135 (@246 @14) +@249 := @162 @9 +@250 := @249 @4 +@255 := {vs : @139} -> {ts : @140} -> (h : @244) -> (hs : @218) -> @248 @250 +@256 := @241 @59 +@257 := @136 @17 +@258 := @60 @228 +@259 := @258 @59 +@264 := {ts : @140} -> (h : @51) -> (hs : @257) -> @135 @259 @250 +@265 := @256 @90 +@266 := @60 @242 +@267 := @266 @59 +@268 := @135 @267 +@269 := @249 @90 +@272 := (h : @55) -> (hs : @137) -> @268 @269 +@273 := @265 @53 +@274 := @63 @59 +@276 := @135 @274 @269 +@277 := (hs : @137) -> @276 +@278 := @273 @134 +@280 := @135 @62 @269 +@281 := @214 @6 +@283 := @45 @245 @4 +@284 := @5 @149 +@285 := @60 @284 +@293 := {t : @88} -> {vs : @139} -> {ts : @140} -> (h : @283) -> (hs : @218) -> @135 (@285 @14) @164 +@294 := @281 @9 +@300 := {vs : @139} -> {ts : @140} -> (h : @229 @9) -> (hs : @218) -> @234 @250 +@301 := @294 @62 +@302 := @268 @17 +@303 := @246 @259 +@304 := @135 @303 +@308 := {ts : @140} -> (h : @244) -> (hs : @302) -> @304 @250 +@309 := @301 @269 +@310 := @258 @267 +@311 := @135 @310 +@312 := @249 @269 +@315 := (h : @51) -> (hs : @276) -> @311 @312 +@316 := @309 @49 +@317 := @266 @274 +@318 := @135 @317 +@320 := (hs : @280) -> @318 @312 +@321 := @316 @278 +@322 := @135 @64 +@323 := @322 @312 +@324 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.denote +@326 := @324 @4 @17 +@327 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.__fits_0 +@329 := @327 @4 @17 +@332 := Production.Main.checkedSum @4 @17 +@336 := LexLeanPreservation.encOption @3 @5 @332 +@339 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.root @4 @17 +@340 := Bool +@341 := Ne.{1} +@342 := LexLeanPreservation.Obs +@343 := @341 @342 +@344 := LexLeanPreservation.Rel +@347 := @343 (@344 @17 @19) +@348 := LexLeanPreservation.Obs.stuck +@351 := (f : @340) -> (v : @56) -> @347 @348 +@353 := LexLeanPreservation.Rust.rel_ne_stuck @329 +@360 := (v : @56) -> @343 (@344 (@327 @14 @4) @19) @348 +@361 := @353 @336 +@365 := @343 (@344 @329 @336) @348 +@366 := @138 @68 +@367 := LexLeanPreservation.Rust.FunSem +@368 := #9 +@374 := (n : @65) -> @367 @368 @155 @149 @19 @141 +@375 := Eq.{1} +@376 := Option.{0} +@377 := @376 @85 +@378 := @375 @377 +@385 := LexLeanRuntime.index (@138 @85) @85 (LexLeanRuntime.instIndexableList @85) +@389 := @378 (@385 (@86 @368) @141) +@390 := Option.some.{0} +@391 := @390 @85 +@392 := @391 @143 +@393 := @389 @392 +@394 := #10 +@398 := @110 @394 @368 @155 @143 +@399 := LexLeanTarget.TargetSyntax.Function.types +@400 := @399 @141 +@401 := @398 @400 +@402 := @376 @366 +@403 := @375 @402 +@404 := LexLeanTarget.TargetSemantics.bindAll +@405 := LexLeanTarget.TargetSyntax.Function.parameters +@410 := @403 (@404 (@405 @149) @141 @78) +@411 := @390 @366 +@412 := @411 @143 +@413 := @410 @412 +@414 := @376 @340 +@415 := @375 @414 +@416 := LexLeanPreservation.Rust.fnFallible +@417 := #11 +@420 := @415 (@416 @417 @368) +@421 := @390 @340 +@422 := @421 @143 +@423 := @420 @422 +@424 := LexLeanPreservation.RunConv +@425 := #13 +@429 := @424 @425 @394 @155 @143 +@431 := @343 @141 @348 +@432 := Exists.{1} +@433 := LexLeanPreservation.Rust.ROut +@434 := @432 @433 +@435 := And +@436 := LexLeanPreservation.Rust.RealizesFn +@440 := @435 (@436 @368 @155 @19) +@441 := LexLeanPreservation.Rust.RCI +@443 := @441 #15 +@444 := LexLeanPreservation.Rust.fnIdent +@445 := @444 @425 +@452 := (hne : @431) -> @434 (fun (ro : @433) => @440 (@443 @445 @417 @19)) +@467 := {p : @10} -> + {c : @11} -> + {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @366} -> + {F : @340} -> + {o : @342} -> + (hB : @374) -> + (hfn : @393) -> (hwt : @401) -> (hbind : @413) -> (hF : @423) -> (hA : @429) -> @452 +@469 := LexLeanPreservation.Rust.compose @0 +@470 := @367 @0 +@475 := (n : @65) -> @470 @155 @149 @19 @141 +@476 := @385 @87 +@479 := @378 (@476 @141) @392 +@483 := @121 @368 @155 @143 @400 +@484 := @424 @0 +@487 := @484 @394 @155 @143 +@501 := {c : @11} -> + {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @366} -> + {F : @340} -> + {o : @342} -> + (hB : @475) -> + (hfn : @479) -> (hwt : @483) -> (hbind : @413) -> (hF : @423) -> (hA : @487) -> @452 +@502 := @469 @1 +@503 := @470 @1 +@507 := (n : @65) -> @503 @149 @19 @141 +@510 := @129 @155 @143 @400 +@511 := @416 @1 +@514 := @415 (@511 @368) @422 +@515 := @441 @1 +@525 := (hbind : @413) -> + (hF : @514) -> (hA : @487) -> (hne : @431) -> @434 (fun (ro : @433) => @440 (@515 @445 @417 @19)) +@535 := {A : @12} -> + {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @366} -> {F : @340} -> {o : @342} -> (hB : @507) -> (hfn : @479) -> (hwt : @510) -> @525 +@536 := @502 @2 +@538 := @503 @2 @19 +@540 := (n : @65) -> @538 @141 +@541 := @135 @143 +@542 := @541 @400 +@551 := {f : @65} -> + {fn : @85} -> + {args : @139} -> + {env : @366} -> {F : @340} -> {o : @342} -> (hB : @540) -> (hfn : @479) -> (hwt : @542) -> @525 +@552 := @536 @75 +@554 := (n : @65) -> @538 @75 +@555 := @476 @75 +@556 := @378 @555 +@557 := @556 @392 +@558 := @511 @75 +@559 := @415 @558 +@560 := @559 @422 +@561 := @484 @75 +@563 := @561 @155 @143 +@565 := @515 (@444 @75) +@573 := (hF : @560) -> (hA : @563) -> (hne : @431) -> @434 (fun (ro : @433) => @440 (@565 @417 @19)) +@582 := {fn : @85} -> + {args : @139} -> + {env : @366} -> + {F : @340} -> {o : @342} -> (hB : @554) -> (hfn : @557) -> (hwt : @542) -> (hbind : @413) -> @573 +@583 := @552 @105 +@585 := @556 (@391 @105) +@586 := @399 @105 +@587 := @541 @586 +@589 := @404 (@405 @105) +@601 := {args : @139} -> + {env : @366} -> + {F : @340} -> + {o : @342} -> + (hB : @554) -> (hfn : @585) -> (hwt : @587) -> (hbind : @403 (@589 @141 @78) @412) -> @573 +@602 := @583 @64 +@604 := @285 (@232 @59) +@606 := @135 @604 @586 +@608 := @60 (@5 @155) +@610 := @608 (@285 @59) +@614 := @403 (@589 @610 @78) @412 +@616 := @60 (@5 @394) +@618 := @60 (@5 @368) +@620 := @616 (@618 @59) +@622 := @561 @620 @143 +@624 := @60 (@5 @425) +@627 := @60 (@5 #12) +@644 := {env : @366} -> + {F : @340} -> + {o : @342} -> + (hB : @554) -> + (hfn : @585) -> + (hwt : @606) -> + (hbind : @614) -> + (hF : @560) -> + (hA : @622) -> (hne : @431) -> @434 (fun (ro : @433) => @440 (@565 (@624 (@627 @59)) @19)) +@645 := @602 @83 +@647 := @232 (@246 @59) +@649 := @135 @647 @586 +@660 := @403 (@589 @604 @78) (@411 (@79 (@73 @231) (@79 (@76 @284) @78))) +@662 := @618 (@608 @59) +@664 := @561 @662 @143 +@666 := @60 (@5 @417) +@682 := {F : @340} -> + {o : @342} -> + (hB : @554) -> + (hfn : @585) -> + (hwt : @649) -> + (hbind : @660) -> + (hF : @560) -> + (hA : @664) -> (hne : @431) -> @434 (fun (ro : @433) => @440 (@565 (@627 (@666 @59)) @19)) +@683 := @645 @84 +@684 := @304 @586 +@695 := @403 (@589 @647 @78) (@411 (@79 (@73 @245) (@79 (@76 @231) @78))) +@697 := @559 (@421 @84) +@699 := @561 @610 @143 +@700 := @436 @84 +@718 := {o : @342} -> + (hB : @554) -> + (hfn : @585) -> + (hwt : @684) -> + (hbind : @695) -> + (hF : @697) -> + (hA : @699) -> + (hne : @431) -> @434 (fun (ro : @433) => @435 (@700 @155 @19) (@565 (@666 (@616 @59)) @19)) +@719 := @683 @326 +@720 := @311 @586 +@731 := @403 (@589 @303 @78) (@411 (@79 (@73 @228) (@79 (@76 @245) @78))) +@732 := @561 @604 +@734 := @324 @149 @141 +@735 := @732 @734 +@737 := @324 @155 @149 +@756 := (hB : @554) -> + (hfn : @585) -> + (hwt : @720) -> + (hbind : @731) -> + (hF : @697) -> + (hA : @735) -> + (hne : @343 @737 @348) -> + @434 (fun (ro : @433) => @435 (@700 (@324 @394 @368) @19) (@565 @620 @19)) +@757 := @719 @109 +@758 := @318 @586 +@769 := @403 (@589 @310 @78) (@411 (@79 (@73 @242) (@79 (@76 @228) @78))) +@770 := @561 @647 +@772 := @324 @141 @143 +@791 := (hfn : @585) -> + (hwt : @758) -> + (hbind : @769) -> + (hF : @697) -> + (hA : @770 @772) -> + (hne : @343 @734 @348) -> + @434 (fun (ro : @433) => @435 (@700 (@324 @368 @155) @19) (@565 @662 @19)) +@792 := Eq.refl.{1} +@795 := @757 (@792 @377 @555) +@796 := @322 @586 +@807 := @403 (@589 @317 @78) (@411 (@79 (@73 @6) (@79 (@76 @242) @78))) +@808 := @561 @303 +@810 := @324 @143 @145 +@826 := (hwt : @796) -> + (hbind : @807) -> + (hF : @697) -> + (hA : @808 @810) -> + (hne : @343 @772 @348) -> @434 (fun (ro : @433) => @435 (@700 @737 @19) (@565 @610 @19)) +@827 := @795 @321 +@829 := @589 @64 @78 +@832 := @403 @829 (@411 @83) +@833 := @561 @310 +@835 := @324 @145 @14 +@850 := (hbind : @832) -> + (hF : @697) -> + (hA : @833 @835) -> + (hne : @343 @810 @348) -> @434 (fun (ro : @433) => @435 (@700 @734 @19) (@565 @604 @19)) +@853 := @827 (@792 @402 @829) +@854 := @561 @317 +@856 := @324 @14 @4 +@870 := (hF : @697) -> + (hA : @854 @856) -> + (hne : @343 @835 @348) -> @434 (fun (ro : @433) => @435 (@700 @772 @19) (@565 @647 @19)) +@873 := @853 (@792 @414 @558) +@887 := (hA : @561 @64 @326) -> + (hne : @343 @856 @348) -> @434 (fun (ro : @433) => @435 (@700 @810 @19) (@565 @303 @19)) +@888 := @873 @339 +@899 := (hne : @343 @326 @348) -> @434 (fun (ro : @433) => @435 (@700 @835 @19) (@565 @310 @19)) +@900 := @888 @361 +@906 := @435 (@700 @856 @19) (@565 @317 @19) +@908 := @434 (fun (ro : @433) => @906) +@910 := @434 (fun (__e_ro : @433) => @906) +@915 := LexLeanPreservation.Rust.RepresentableL (@61 (@60 @20 @59)) +@916 := (__e_hrep : @915) -> @910 +@917 := fun (__e_hrep : @915) => @900 +@918 := (right : @3) -> @916 +@919 := fun (right : @3) => @917 +@920 := (left : @3) -> @918 +@921 := fun (left : @3) => @919 +\end{coremodule} +\end{lexlean} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustCore.lean deleted file mode 100644 index 2ed67300b..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustCore.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1 -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore - -theorem __wt_0 : ∀ (__v : (Production.Kernel.Shape)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.program _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.krate _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.flags (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.__enc_0 __v) (.adt 0) - | Production.Kernel.Shape.circle __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - | Production.Kernel.Shape.rectangle __x0 __x1 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x1) _root_.LexLeanPreservation.Rust.wtl_nil)) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (width : Nat) (height : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat width), (_root_.LexLeanTarget.TargetSyntax.Value.nat height)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.denote width height) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat width), (_root_.LexLeanTarget.TargetSyntax.Value.nat height)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat width) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat height) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.root width height) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustCore.lex.tex new file mode 100644 index 000000000..d88c037f8 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustCore.lex.tex @@ -0,0 +1,565 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1, + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore.__wt_0 : @16 := @453 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore.root : @1128 := @1129 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.program +@1 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.krate +@2 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.flags +@3 := Production.Kernel.Shape +@4 := #0 +@6 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.__enc_0 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := (__v : @3) -> @15 +@17 := fun (__v : @3) => @15 +@18 := LexLeanTarget.TargetSyntax.Value.nat +@19 := @18 @4 +@20 := LexLeanTarget.TargetSyntax.Ty.nat +@21 := LexLeanTarget.TargetSyntax.Program +@22 := LexLeanPreservation.Rust.RCrate +@23 := LexLeanPreservation.Rust.Flags +@24 := Nat +@25 := #3 +@26 := @7 @25 +@27 := #2 +@28 := @26 @27 +@29 := #1 +@36 := {p : @21} -> {c : @22} -> {A : @23} -> (n : @24) -> @28 @29 @19 @20 +@38 := LexLeanPreservation.Rust.wt_nat @0 +@45 := {c : @22} -> {A : @23} -> (n : @24) -> @11 @27 @29 @19 @20 +@46 := @38 @1 +@51 := {A : @23} -> (n : @24) -> @12 @29 @19 @20 +@52 := @46 @2 +@54 := @13 @19 @20 +@55 := (n : @24) -> @54 +@56 := @52 @4 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := LexLeanTarget.TargetSyntax.Ty +@59 := List.nil.{0} +@60 := List.cons.{0} +@61 := @59 @57 +@62 := @60 @57 +@64 := @62 @19 @61 +@65 := @59 @58 +@66 := @60 @58 +@67 := @66 @20 +@68 := @67 @65 +@69 := LexLeanPreservation.Rust.WTL +@77 := {p : @21} -> {c : @22} -> {A : @23} -> @69 @27 @29 @4 @61 @65 +@79 := LexLeanPreservation.Rust.wtl_nil @0 +@80 := @69 @0 +@86 := {c : @22} -> {A : @23} -> @80 @29 @4 @61 @65 +@87 := @79 @1 +@88 := @80 @1 +@92 := {A : @23} -> @88 @4 @61 @65 +@93 := @87 @2 +@94 := @88 @2 +@95 := @94 @61 +@96 := @95 @65 +@97 := List.{0} +@98 := @97 @57 +@99 := @97 @58 +@100 := #6 +@101 := @7 @100 +@102 := #5 +@103 := @101 @102 +@104 := #4 +@107 := @103 @104 @25 @27 +@108 := #7 +@113 := @69 @108 @100 @102 @27 @29 +@114 := #8 +@117 := @69 @114 @108 @100 +@119 := @62 @102 @25 +@120 := @117 @119 +@122 := @66 @104 @27 +@132 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {v : @57} -> {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @107) -> (hs : @113) -> @120 @122 +@134 := LexLeanPreservation.Rust.wtl_cons @0 +@138 := @11 @102 @104 @25 @27 +@142 := @80 @100 @102 @27 @29 +@154 := {c : @22} -> + {A : @23} -> + {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @138) -> (hs : @142) -> @80 @108 @100 @119 @122 +@155 := @134 @1 +@158 := @12 @104 @25 @27 +@161 := @88 @102 @27 @29 +@171 := {A : @23} -> + {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @158) -> (hs : @161) -> @88 @100 @119 @122 +@172 := @155 @2 +@174 := @13 @25 @27 +@176 := @94 @27 @29 +@184 := {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @174) -> (hs : @176) -> @94 @119 @122 +@185 := @172 @19 +@186 := @18 @25 +@187 := @13 @186 +@188 := @187 @27 +@189 := @18 @102 +@190 := @62 @189 +@192 := @94 (@190 @25) +@198 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @188) -> (hs : @176) -> @192 @122 +@199 := @185 @20 +@200 := @18 @27 +@202 := @13 @200 @20 +@203 := @18 @104 +@204 := @62 @203 +@206 := @94 (@204 @25) +@207 := @67 @27 +@212 := {vs : @98} -> {ts : @99} -> (h : @202) -> (hs : @176) -> @206 @207 +@213 := @199 @61 +@214 := @18 @29 +@216 := @13 @214 @20 +@217 := @95 @29 +@218 := @62 @186 +@219 := @218 @61 +@220 := @94 @219 +@224 := {ts : @99} -> (h : @216) -> (hs : @217) -> @220 @207 +@225 := @213 @65 +@226 := @62 @200 +@227 := @226 @61 +@228 := @94 @227 +@229 := @228 @68 +@231 := (h : @54) -> (hs : @96) -> @229 +@232 := @225 @56 +@233 := @62 @214 +@234 := @233 @61 +@236 := @94 @234 @68 +@237 := (hs : @96) -> @236 +@238 := @232 @93 +@240 := @94 @64 @68 +@241 := Eq.{1} +@242 := Option.{0} +@243 := @242 @99 +@244 := @241 @243 +@245 := LexLeanPreservation.Rust.adtFields +@249 := @244 (@245 @100 @25 @27) +@250 := Option.some.{0} +@251 := @250 @99 +@252 := @251 @4 +@253 := @249 @252 +@256 := @7 @114 @108 @100 +@257 := LexLeanTarget.TargetSyntax.Value.adt +@259 := @257 @104 @25 +@260 := @256 @259 +@261 := @8 @102 +@271 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {i : @24} -> {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @253) -> (hf : @113) -> @260 @261 +@273 := LexLeanPreservation.Rust.wt_adt @0 +@274 := @245 @0 +@278 := @244 (@274 @25 @27) @252 +@290 := {c : @22} -> + {A : @23} -> + {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @142) -> @11 @108 @100 @259 @261 +@291 := @273 @1 +@301 := {A : @23} -> + {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @161) -> @12 @100 @259 @261 +@302 := @291 @2 +@303 := @13 @259 +@310 := {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @176) -> @303 @261 +@311 := @302 @9 +@312 := @274 @9 +@321 := {k : @24} -> + {fs : @98} -> {tys : @99} -> (h : @244 (@312 @27) @252) -> (hf : @176) -> @303 @10 +@322 := @311 @9 +@323 := @312 @9 +@324 := @244 @323 +@325 := @324 @252 +@326 := @257 @9 +@333 := {fs : @98} -> {tys : @99} -> (h : @325) -> (hf : @176) -> @13 (@326 @25) @10 +@334 := @322 @64 +@335 := @228 @29 +@341 := {tys : @99} -> (h : @325) -> (hf : @335) -> @13 (@326 @219) @10 +@342 := @334 @68 +@349 := (h : @324 (@251 @68)) -> (hf : @236) -> @13 (@326 @227) @10 +@350 := Eq.refl.{1} +@351 := @350 @243 +@353 := @342 (@351 @323) +@357 := (hf : @240) -> @13 (@326 @234) @10 +@358 := @353 @238 +@361 := @13 (@326 @64) @10 +@362 := fun (__x0 : @24) => @358 +@363 := @52 @29 +@364 := @233 @64 +@365 := @67 @68 +@366 := @172 @214 +@367 := @13 @203 +@368 := @367 @27 +@369 := @18 @100 +@370 := @62 @369 +@372 := @94 (@370 @25) +@378 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @368) -> (hs : @176) -> @372 @122 +@379 := @366 @20 +@380 := @187 @20 +@385 := {vs : @98} -> {ts : @99} -> (h : @380) -> (hs : @176) -> @192 @207 +@386 := @379 @64 +@387 := @204 @219 +@388 := @94 @387 +@392 := {ts : @99} -> (h : @202) -> (hs : @335) -> @388 @207 +@393 := @386 @68 +@394 := @218 @227 +@395 := @94 @394 +@398 := (h : @216) -> (hs : @236) -> @395 @365 +@399 := @393 @363 +@400 := @226 @234 +@401 := @94 @400 +@402 := @401 @365 +@403 := (hs : @240) -> @402 +@404 := @399 @238 +@406 := @94 @364 @365 +@407 := 1 +@408 := @311 @407 +@409 := @312 @407 +@410 := @244 @409 +@411 := @410 @252 +@412 := @257 @407 +@419 := {fs : @98} -> {tys : @99} -> (h : @411) -> (hf : @176) -> @13 (@412 @25) @10 +@420 := @408 @364 +@427 := {tys : @99} -> (h : @411) -> (hf : @395 @29) -> @13 (@412 @387) @10 +@428 := @420 @365 +@435 := (h : @410 (@251 @365)) -> (hf : @402) -> @13 (@412 @394) @10 +@437 := @428 (@351 @409) +@441 := (hf : @406) -> @13 (@412 @400) @10 +@442 := @437 @404 +@445 := @13 (@412 @364) @10 +@447 := fun (__x0 : @24) => fun (__x1 : @24) => @442 +@453 := fun (__v : @3) => Production.Kernel.Shape.casesOn.{0} @17 @4 @362 @447 +@454 := @52 @27 +@457 := Prod.{0, 0} @24 @57 +@460 := Prod.mk.{0, 0} @24 @57 +@461 := @460 @407 +@462 := @461 @214 +@463 := @460 @9 +@464 := @463 @200 +@465 := @59 @457 +@466 := @60 @457 +@468 := @466 @464 @465 +@470 := @466 @462 @468 +@471 := Bool.true +@472 := LexLeanTarget.TargetSyntax.Function +@473 := LexLeanTarget.TargetSyntax.Program.functions +@474 := @473 @0 +@475 := @59 @24 +@476 := LexLeanTarget.TargetSyntax.Ty.unit +@477 := LexLeanTarget.TargetSyntax.Value.unit +@480 := LexLeanTarget.TargetSyntax.Expr.value @476 @477 +@485 := LexLeanTarget.TargetSyntax.Function.mk @475 @65 @476 @480 +@490 := List.getD.{0} @472 @474 @9 @485 +@494 := fun (__e_n : @24) => + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.root @4 @9 +@495 := @379 @61 +@496 := @204 @61 +@501 := {ts : @99} -> (h : @202) -> (hs : @217) -> @94 @496 @207 +@502 := @495 @65 +@505 := (h : @216) -> (hs : @96) -> @220 @68 +@507 := @502 @363 @93 +@508 := @172 @200 +@510 := @13 @189 @27 +@511 := @18 @108 +@512 := @62 @511 +@520 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @510) -> (hs : @176) -> @94 (@512 @25) @122 +@521 := @508 @20 +@527 := {vs : @98} -> {ts : @99} -> (h : @367 @20) -> (hs : @176) -> @372 @207 +@528 := @521 @234 +@529 := @220 @29 +@530 := @190 @496 +@531 := @94 @530 +@535 := {ts : @99} -> (h : @380) -> (hs : @529) -> @531 @207 +@536 := @528 @68 +@539 := (h : @202) -> (hs : @229) -> @388 @365 +@541 := @536 @454 @507 +@542 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.denote +@544 := @542 @27 @29 +@545 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.__fits_0 +@547 := @545 @27 @29 +@551 := @18 (Production.Main.shapeArea @27 @29) +@554 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.root @27 @29 +@555 := Bool +@556 := Ne.{1} +@557 := LexLeanPreservation.Obs +@558 := @556 @557 +@559 := LexLeanPreservation.Rel +@562 := @558 (@559 @29 @4) +@563 := LexLeanPreservation.Obs.stuck +@566 := (f : @555) -> (v : @57) -> @562 @563 +@568 := LexLeanPreservation.Rust.rel_ne_stuck @547 +@575 := (v : @57) -> @558 (@559 (@545 @25 @27) @4) @563 +@576 := @568 @551 +@580 := @558 (@559 @547 @551) @563 +@581 := @97 @457 +@582 := LexLeanPreservation.Rust.FunSem +@583 := #9 +@589 := (n : @24) -> @582 @583 @114 @108 @4 @100 +@590 := @242 @472 +@591 := @241 @590 +@598 := LexLeanRuntime.index (@97 @472) @472 (LexLeanRuntime.instIndexableList @472) +@602 := @591 (@598 (@473 @583) @100) +@603 := @250 @472 +@604 := @603 @102 +@605 := @602 @604 +@606 := #10 +@610 := @69 @606 @583 @114 @102 +@611 := LexLeanTarget.TargetSyntax.Function.types +@612 := @611 @100 +@613 := @610 @612 +@614 := @242 @581 +@615 := @241 @614 +@616 := LexLeanTarget.TargetSemantics.bindAll +@617 := LexLeanTarget.TargetSyntax.Function.parameters +@622 := @615 (@616 (@617 @108) @100 @465) +@623 := @250 @581 +@624 := @623 @102 +@625 := @622 @624 +@626 := @242 @555 +@627 := @241 @626 +@628 := LexLeanPreservation.Rust.fnFallible +@629 := #11 +@632 := @627 (@628 @629 @583) +@633 := @250 @555 +@634 := @633 @102 +@635 := @632 @634 +@636 := LexLeanPreservation.RunConv +@637 := #13 +@641 := @636 @637 @606 @114 @102 +@643 := @558 @100 @563 +@644 := Exists.{1} +@645 := LexLeanPreservation.Rust.ROut +@646 := @644 @645 +@647 := And +@648 := LexLeanPreservation.Rust.RealizesFn +@652 := @647 (@648 @583 @114 @4) +@653 := LexLeanPreservation.Rust.RCI +@655 := @653 #15 +@656 := LexLeanPreservation.Rust.fnIdent +@657 := @656 @637 +@664 := (hne : @643) -> @646 (fun (ro : @645) => @652 (@655 @657 @629 @4)) +@679 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {f : @24} -> + {fn : @472} -> + {args : @98} -> + {env : @581} -> + {F : @555} -> + {o : @557} -> + (hB : @589) -> + (hfn : @605) -> (hwt : @613) -> (hbind : @625) -> (hF : @635) -> (hA : @641) -> @664 +@681 := LexLeanPreservation.Rust.compose @0 +@682 := @582 @0 +@687 := (n : @24) -> @682 @114 @108 @4 @100 +@688 := @598 @474 +@691 := @591 (@688 @100) @604 +@695 := @80 @583 @114 @102 @612 +@696 := @636 @0 +@699 := @696 @606 @114 @102 +@713 := {c : @22} -> + {A : @23} -> + {f : @24} -> + {fn : @472} -> + {args : @98} -> + {env : @581} -> + {F : @555} -> + {o : @557} -> + (hB : @687) -> + (hfn : @691) -> (hwt : @695) -> (hbind : @625) -> (hF : @635) -> (hA : @699) -> @664 +@714 := @681 @1 +@715 := @682 @1 +@719 := (n : @24) -> @715 @108 @4 @100 +@722 := @88 @114 @102 @612 +@723 := @628 @1 +@726 := @627 (@723 @583) @634 +@727 := @653 @1 +@737 := (hbind : @625) -> + (hF : @726) -> (hA : @699) -> (hne : @643) -> @646 (fun (ro : @645) => @652 (@727 @657 @629 @4)) +@747 := {A : @23} -> + {f : @24} -> + {fn : @472} -> + {args : @98} -> + {env : @581} -> {F : @555} -> {o : @557} -> (hB : @719) -> (hfn : @691) -> (hwt : @722) -> @737 +@748 := @714 @2 +@750 := @715 @2 @4 +@752 := (n : @24) -> @750 @100 +@753 := @94 @102 +@754 := @753 @612 +@763 := {f : @24} -> + {fn : @472} -> + {args : @98} -> + {env : @581} -> {F : @555} -> {o : @557} -> (hB : @752) -> (hfn : @691) -> (hwt : @754) -> @737 +@764 := @748 @9 +@766 := (n : @24) -> @750 @9 +@767 := @688 @9 +@768 := @591 @767 +@769 := @768 @604 +@770 := @723 @9 +@771 := @627 @770 +@772 := @771 @634 +@773 := @696 @9 +@775 := @773 @114 @102 +@777 := @727 (@656 @9) +@785 := (hF : @772) -> (hA : @775) -> (hne : @643) -> @646 (fun (ro : @645) => @652 (@777 @629 @4)) +@794 := {fn : @472} -> + {args : @98} -> + {env : @581} -> + {F : @555} -> {o : @557} -> (hB : @766) -> (hfn : @769) -> (hwt : @754) -> (hbind : @625) -> @785 +@795 := @764 @490 +@797 := @768 (@603 @490) +@798 := @611 @490 +@799 := @753 @798 +@801 := @616 (@617 @490) +@813 := {args : @98} -> + {env : @581} -> + {F : @555} -> + {o : @557} -> + (hB : @766) -> (hfn : @797) -> (hwt : @799) -> (hbind : @615 (@801 @100 @465) @624) -> @785 +@814 := @795 @400 +@816 := @512 (@370 @61) +@818 := @94 @816 @798 +@820 := @62 (@18 @114) +@822 := @820 (@512 @61) +@826 := @615 (@801 @822 @465) @624 +@828 := @62 (@18 @606) +@830 := @62 (@18 @583) +@832 := @828 (@830 @61) +@834 := @773 @832 @102 +@836 := @62 (@18 @637) +@839 := @62 (@18 #12) +@856 := {env : @581} -> + {F : @555} -> + {o : @557} -> + (hB : @766) -> + (hfn : @797) -> + (hwt : @818) -> + (hbind : @826) -> + (hF : @772) -> + (hA : @834) -> (hne : @643) -> @646 (fun (ro : @645) => @652 (@777 (@836 (@839 @61)) @4)) +@857 := @814 @470 +@859 := @370 (@190 @61) +@861 := @94 @859 @798 +@872 := @615 (@801 @816 @465) (@623 (@466 (@461 @369) (@466 (@463 @511) @465))) +@874 := @830 (@820 @61) +@876 := @773 @874 @102 +@878 := @62 (@18 @629) +@894 := {F : @555} -> + {o : @557} -> + (hB : @766) -> + (hfn : @797) -> + (hwt : @861) -> + (hbind : @872) -> + (hF : @772) -> + (hA : @876) -> (hne : @643) -> @646 (fun (ro : @645) => @652 (@777 (@839 (@878 @61)) @4)) +@895 := @857 @471 +@896 := @531 @798 +@907 := @615 (@801 @859 @465) (@623 (@466 (@461 @189) (@466 (@463 @369) @465))) +@909 := @771 (@633 @471) +@911 := @773 @822 @102 +@912 := @648 @471 +@930 := {o : @557} -> + (hB : @766) -> + (hfn : @797) -> + (hwt : @896) -> + (hbind : @907) -> + (hF : @909) -> + (hA : @911) -> + (hne : @643) -> @646 (fun (ro : @645) => @647 (@912 @114 @4) (@777 (@878 (@828 @61)) @4)) +@931 := @895 @544 +@932 := @388 @798 +@943 := @615 (@801 @530 @465) (@623 (@466 (@461 @203) (@466 (@463 @189) @465))) +@944 := @773 @816 +@946 := @542 @108 @100 +@947 := @944 @946 +@949 := @542 @114 @108 +@968 := (hB : @766) -> + (hfn : @797) -> + (hwt : @932) -> + (hbind : @943) -> + (hF : @909) -> + (hA : @947) -> + (hne : @558 @949 @563) -> @646 (fun (ro : @645) => @647 (@912 (@542 @606 @583) @4) (@777 @832 @4)) +@969 := @931 @494 +@970 := @395 @798 +@981 := @615 (@801 @387 @465) (@623 (@466 (@461 @186) (@466 (@463 @203) @465))) +@982 := @773 @859 +@984 := @542 @100 @102 +@1003 := (hfn : @797) -> + (hwt : @970) -> + (hbind : @981) -> + (hF : @909) -> + (hA : @982 @984) -> + (hne : @558 @946 @563) -> @646 (fun (ro : @645) => @647 (@912 (@542 @583 @114) @4) (@777 @874 @4)) +@1006 := @969 (@350 @590 @767) +@1007 := @401 @798 +@1018 := @615 (@801 @394 @465) (@623 (@466 (@461 @200) (@466 (@463 @186) @465))) +@1019 := @773 @530 +@1021 := @542 @102 @104 +@1037 := (hwt : @1007) -> + (hbind : @1018) -> + (hF : @909) -> + (hA : @1019 @1021) -> + (hne : @558 @984 @563) -> @646 (fun (ro : @645) => @647 (@912 @949 @4) (@777 @822 @4)) +@1038 := @1006 @541 +@1040 := @801 @400 @465 +@1043 := @615 @1040 (@623 @470) +@1044 := @773 @387 +@1046 := @542 @104 @25 +@1061 := (hbind : @1043) -> + (hF : @909) -> + (hA : @1044 @1046) -> + (hne : @558 @1021 @563) -> @646 (fun (ro : @645) => @647 (@912 @946 @4) (@777 @816 @4)) +@1064 := @1038 (@350 @614 @1040) +@1065 := @773 @394 +@1067 := @542 @25 @27 +@1081 := (hF : @909) -> + (hA : @1065 @1067) -> + (hne : @558 @1046 @563) -> @646 (fun (ro : @645) => @647 (@912 @984 @4) (@777 @859 @4)) +@1084 := @1064 (@350 @626 @770) +@1098 := (hA : @773 @400 @544) -> + (hne : @558 @1067 @563) -> @646 (fun (ro : @645) => @647 (@912 @1021 @4) (@777 @530 @4)) +@1099 := @1084 @554 +@1110 := (hne : @558 @544 @563) -> @646 (fun (ro : @645) => @647 (@912 @1046 @4) (@777 @387 @4)) +@1111 := @1099 @576 +@1117 := @647 (@912 @1067 @4) (@777 @394 @4) +@1119 := @646 (fun (ro : @645) => @1117) +@1121 := @646 (fun (__e_ro : @645) => @1117) +@1123 := LexLeanPreservation.Rust.RepresentableL @364 +@1124 := (__e_hrep : @1123) -> @1121 +@1125 := fun (__e_hrep : @1123) => @1111 +@1126 := (height : @24) -> @1124 +@1127 := fun (height : @24) => @1125 +@1128 := (width : @24) -> @1126 +@1129 := fun (width : @24) => @1127 +\end{coremodule} +\end{lexlean} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustStd.lean deleted file mode 100644 index fdd913acb..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1 -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Production.Kernel.Shape)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.program _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.krate _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.flags (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.__enc_0 __v) (.adt 0) - | Production.Kernel.Shape.circle __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - | Production.Kernel.Shape.rectangle __x0 __x1 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x1) _root_.LexLeanPreservation.Rust.wtl_nil)) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (width : Nat) (height : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat width), (_root_.LexLeanTarget.TargetSyntax.Value.nat height)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.denote width height) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat width), (_root_.LexLeanTarget.TargetSyntax.Value.nat height)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat width) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat height) _root_.LexLeanPreservation.Rust.wtl_nil)) rfl rfl (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.root width height) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustStd.lex.tex new file mode 100644 index 000000000..48d431a0a --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustStd.lex.tex @@ -0,0 +1,564 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1, + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd.__wt_0 : @16 := @453 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd.root : @1128 := @1129 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.program +@1 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.krate +@2 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.flags +@3 := Production.Kernel.Shape +@4 := #0 +@6 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.__enc_0 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@15 := @13 @6 @10 +@16 := (__v : @3) -> @15 +@17 := fun (__v : @3) => @15 +@18 := LexLeanTarget.TargetSyntax.Value.nat +@19 := @18 @4 +@20 := LexLeanTarget.TargetSyntax.Ty.nat +@21 := LexLeanTarget.TargetSyntax.Program +@22 := LexLeanPreservation.Rust.RCrate +@23 := LexLeanPreservation.Rust.Flags +@24 := Nat +@25 := #3 +@26 := @7 @25 +@27 := #2 +@28 := @26 @27 +@29 := #1 +@36 := {p : @21} -> {c : @22} -> {A : @23} -> (n : @24) -> @28 @29 @19 @20 +@38 := LexLeanPreservation.Rust.wt_nat @0 +@45 := {c : @22} -> {A : @23} -> (n : @24) -> @11 @27 @29 @19 @20 +@46 := @38 @1 +@51 := {A : @23} -> (n : @24) -> @12 @29 @19 @20 +@52 := @46 @2 +@54 := @13 @19 @20 +@55 := (n : @24) -> @54 +@56 := @52 @4 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := LexLeanTarget.TargetSyntax.Ty +@59 := List.nil.{0} +@60 := List.cons.{0} +@61 := @59 @57 +@62 := @60 @57 +@64 := @62 @19 @61 +@65 := @59 @58 +@66 := @60 @58 +@67 := @66 @20 +@68 := @67 @65 +@69 := LexLeanPreservation.Rust.WTL +@77 := {p : @21} -> {c : @22} -> {A : @23} -> @69 @27 @29 @4 @61 @65 +@79 := LexLeanPreservation.Rust.wtl_nil @0 +@80 := @69 @0 +@86 := {c : @22} -> {A : @23} -> @80 @29 @4 @61 @65 +@87 := @79 @1 +@88 := @80 @1 +@92 := {A : @23} -> @88 @4 @61 @65 +@93 := @87 @2 +@94 := @88 @2 +@95 := @94 @61 +@96 := @95 @65 +@97 := List.{0} +@98 := @97 @57 +@99 := @97 @58 +@100 := #6 +@101 := @7 @100 +@102 := #5 +@103 := @101 @102 +@104 := #4 +@107 := @103 @104 @25 @27 +@108 := #7 +@113 := @69 @108 @100 @102 @27 @29 +@114 := #8 +@117 := @69 @114 @108 @100 +@119 := @62 @102 @25 +@120 := @117 @119 +@122 := @66 @104 @27 +@132 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {v : @57} -> {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @107) -> (hs : @113) -> @120 @122 +@134 := LexLeanPreservation.Rust.wtl_cons @0 +@138 := @11 @102 @104 @25 @27 +@142 := @80 @100 @102 @27 @29 +@154 := {c : @22} -> + {A : @23} -> + {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @138) -> (hs : @142) -> @80 @108 @100 @119 @122 +@155 := @134 @1 +@158 := @12 @104 @25 @27 +@161 := @88 @102 @27 @29 +@171 := {A : @23} -> + {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @158) -> (hs : @161) -> @88 @100 @119 @122 +@172 := @155 @2 +@174 := @13 @25 @27 +@176 := @94 @27 @29 +@184 := {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @174) -> (hs : @176) -> @94 @119 @122 +@185 := @172 @19 +@186 := @18 @25 +@187 := @13 @186 +@188 := @187 @27 +@189 := @18 @102 +@190 := @62 @189 +@192 := @94 (@190 @25) +@198 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @188) -> (hs : @176) -> @192 @122 +@199 := @185 @20 +@200 := @18 @27 +@202 := @13 @200 @20 +@203 := @18 @104 +@204 := @62 @203 +@206 := @94 (@204 @25) +@207 := @67 @27 +@212 := {vs : @98} -> {ts : @99} -> (h : @202) -> (hs : @176) -> @206 @207 +@213 := @199 @61 +@214 := @18 @29 +@216 := @13 @214 @20 +@217 := @95 @29 +@218 := @62 @186 +@219 := @218 @61 +@220 := @94 @219 +@224 := {ts : @99} -> (h : @216) -> (hs : @217) -> @220 @207 +@225 := @213 @65 +@226 := @62 @200 +@227 := @226 @61 +@228 := @94 @227 +@229 := @228 @68 +@231 := (h : @54) -> (hs : @96) -> @229 +@232 := @225 @56 +@233 := @62 @214 +@234 := @233 @61 +@236 := @94 @234 @68 +@237 := (hs : @96) -> @236 +@238 := @232 @93 +@240 := @94 @64 @68 +@241 := Eq.{1} +@242 := Option.{0} +@243 := @242 @99 +@244 := @241 @243 +@245 := LexLeanPreservation.Rust.adtFields +@249 := @244 (@245 @100 @25 @27) +@250 := Option.some.{0} +@251 := @250 @99 +@252 := @251 @4 +@253 := @249 @252 +@256 := @7 @114 @108 @100 +@257 := LexLeanTarget.TargetSyntax.Value.adt +@259 := @257 @104 @25 +@260 := @256 @259 +@261 := @8 @102 +@271 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {i : @24} -> {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @253) -> (hf : @113) -> @260 @261 +@273 := LexLeanPreservation.Rust.wt_adt @0 +@274 := @245 @0 +@278 := @244 (@274 @25 @27) @252 +@290 := {c : @22} -> + {A : @23} -> + {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @142) -> @11 @108 @100 @259 @261 +@291 := @273 @1 +@301 := {A : @23} -> + {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @161) -> @12 @100 @259 @261 +@302 := @291 @2 +@303 := @13 @259 +@310 := {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @176) -> @303 @261 +@311 := @302 @9 +@312 := @274 @9 +@321 := {k : @24} -> + {fs : @98} -> {tys : @99} -> (h : @244 (@312 @27) @252) -> (hf : @176) -> @303 @10 +@322 := @311 @9 +@323 := @312 @9 +@324 := @244 @323 +@325 := @324 @252 +@326 := @257 @9 +@333 := {fs : @98} -> {tys : @99} -> (h : @325) -> (hf : @176) -> @13 (@326 @25) @10 +@334 := @322 @64 +@335 := @228 @29 +@341 := {tys : @99} -> (h : @325) -> (hf : @335) -> @13 (@326 @219) @10 +@342 := @334 @68 +@349 := (h : @324 (@251 @68)) -> (hf : @236) -> @13 (@326 @227) @10 +@350 := Eq.refl.{1} +@351 := @350 @243 +@353 := @342 (@351 @323) +@357 := (hf : @240) -> @13 (@326 @234) @10 +@358 := @353 @238 +@361 := @13 (@326 @64) @10 +@362 := fun (__x0 : @24) => @358 +@363 := @52 @29 +@364 := @233 @64 +@365 := @67 @68 +@366 := @172 @214 +@367 := @13 @203 +@368 := @367 @27 +@369 := @18 @100 +@370 := @62 @369 +@372 := @94 (@370 @25) +@378 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @368) -> (hs : @176) -> @372 @122 +@379 := @366 @20 +@380 := @187 @20 +@385 := {vs : @98} -> {ts : @99} -> (h : @380) -> (hs : @176) -> @192 @207 +@386 := @379 @64 +@387 := @204 @219 +@388 := @94 @387 +@392 := {ts : @99} -> (h : @202) -> (hs : @335) -> @388 @207 +@393 := @386 @68 +@394 := @218 @227 +@395 := @94 @394 +@398 := (h : @216) -> (hs : @236) -> @395 @365 +@399 := @393 @363 +@400 := @226 @234 +@401 := @94 @400 +@402 := @401 @365 +@403 := (hs : @240) -> @402 +@404 := @399 @238 +@406 := @94 @364 @365 +@407 := 1 +@408 := @311 @407 +@409 := @312 @407 +@410 := @244 @409 +@411 := @410 @252 +@412 := @257 @407 +@419 := {fs : @98} -> {tys : @99} -> (h : @411) -> (hf : @176) -> @13 (@412 @25) @10 +@420 := @408 @364 +@427 := {tys : @99} -> (h : @411) -> (hf : @395 @29) -> @13 (@412 @387) @10 +@428 := @420 @365 +@435 := (h : @410 (@251 @365)) -> (hf : @402) -> @13 (@412 @394) @10 +@437 := @428 (@351 @409) +@441 := (hf : @406) -> @13 (@412 @400) @10 +@442 := @437 @404 +@445 := @13 (@412 @364) @10 +@447 := fun (__x0 : @24) => fun (__x1 : @24) => @442 +@453 := fun (__v : @3) => Production.Kernel.Shape.casesOn.{0} @17 @4 @362 @447 +@454 := @52 @27 +@457 := Prod.{0, 0} @24 @57 +@460 := Prod.mk.{0, 0} @24 @57 +@461 := @460 @407 +@462 := @461 @214 +@463 := @460 @9 +@464 := @463 @200 +@465 := @59 @457 +@466 := @60 @457 +@468 := @466 @464 @465 +@470 := @466 @462 @468 +@471 := Bool.true +@472 := LexLeanTarget.TargetSyntax.Function +@473 := LexLeanTarget.TargetSyntax.Program.functions +@474 := @473 @0 +@475 := @59 @24 +@476 := LexLeanTarget.TargetSyntax.Ty.unit +@477 := LexLeanTarget.TargetSyntax.Value.unit +@480 := LexLeanTarget.TargetSyntax.Expr.value @476 @477 +@485 := LexLeanTarget.TargetSyntax.Function.mk @475 @65 @476 @480 +@490 := List.getD.{0} @472 @474 @9 @485 +@494 := fun (__e_n : @24) => LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.root @4 @9 +@495 := @379 @61 +@496 := @204 @61 +@501 := {ts : @99} -> (h : @202) -> (hs : @217) -> @94 @496 @207 +@502 := @495 @65 +@505 := (h : @216) -> (hs : @96) -> @220 @68 +@507 := @502 @363 @93 +@508 := @172 @200 +@510 := @13 @189 @27 +@511 := @18 @108 +@512 := @62 @511 +@520 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @510) -> (hs : @176) -> @94 (@512 @25) @122 +@521 := @508 @20 +@527 := {vs : @98} -> {ts : @99} -> (h : @367 @20) -> (hs : @176) -> @372 @207 +@528 := @521 @234 +@529 := @220 @29 +@530 := @190 @496 +@531 := @94 @530 +@535 := {ts : @99} -> (h : @380) -> (hs : @529) -> @531 @207 +@536 := @528 @68 +@539 := (h : @202) -> (hs : @229) -> @388 @365 +@541 := @536 @454 @507 +@542 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.denote +@544 := @542 @27 @29 +@545 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.__fits_0 +@547 := @545 @27 @29 +@551 := @18 (Production.Main.shapeArea @27 @29) +@554 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.root @27 @29 +@555 := Bool +@556 := Ne.{1} +@557 := LexLeanPreservation.Obs +@558 := @556 @557 +@559 := LexLeanPreservation.Rel +@562 := @558 (@559 @29 @4) +@563 := LexLeanPreservation.Obs.stuck +@566 := (f : @555) -> (v : @57) -> @562 @563 +@568 := LexLeanPreservation.Rust.rel_ne_stuck @547 +@575 := (v : @57) -> @558 (@559 (@545 @25 @27) @4) @563 +@576 := @568 @551 +@580 := @558 (@559 @547 @551) @563 +@581 := @97 @457 +@582 := LexLeanPreservation.Rust.FunSem +@583 := #9 +@589 := (n : @24) -> @582 @583 @114 @108 @4 @100 +@590 := @242 @472 +@591 := @241 @590 +@598 := LexLeanRuntime.index (@97 @472) @472 (LexLeanRuntime.instIndexableList @472) +@602 := @591 (@598 (@473 @583) @100) +@603 := @250 @472 +@604 := @603 @102 +@605 := @602 @604 +@606 := #10 +@610 := @69 @606 @583 @114 @102 +@611 := LexLeanTarget.TargetSyntax.Function.types +@612 := @611 @100 +@613 := @610 @612 +@614 := @242 @581 +@615 := @241 @614 +@616 := LexLeanTarget.TargetSemantics.bindAll +@617 := LexLeanTarget.TargetSyntax.Function.parameters +@622 := @615 (@616 (@617 @108) @100 @465) +@623 := @250 @581 +@624 := @623 @102 +@625 := @622 @624 +@626 := @242 @555 +@627 := @241 @626 +@628 := LexLeanPreservation.Rust.fnFallible +@629 := #11 +@632 := @627 (@628 @629 @583) +@633 := @250 @555 +@634 := @633 @102 +@635 := @632 @634 +@636 := LexLeanPreservation.RunConv +@637 := #13 +@641 := @636 @637 @606 @114 @102 +@643 := @558 @100 @563 +@644 := Exists.{1} +@645 := LexLeanPreservation.Rust.ROut +@646 := @644 @645 +@647 := And +@648 := LexLeanPreservation.Rust.RealizesFn +@652 := @647 (@648 @583 @114 @4) +@653 := LexLeanPreservation.Rust.RCI +@655 := @653 #15 +@656 := LexLeanPreservation.Rust.fnIdent +@657 := @656 @637 +@664 := (hne : @643) -> @646 (fun (ro : @645) => @652 (@655 @657 @629 @4)) +@679 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {f : @24} -> + {fn : @472} -> + {args : @98} -> + {env : @581} -> + {F : @555} -> + {o : @557} -> + (hB : @589) -> + (hfn : @605) -> (hwt : @613) -> (hbind : @625) -> (hF : @635) -> (hA : @641) -> @664 +@681 := LexLeanPreservation.Rust.compose @0 +@682 := @582 @0 +@687 := (n : @24) -> @682 @114 @108 @4 @100 +@688 := @598 @474 +@691 := @591 (@688 @100) @604 +@695 := @80 @583 @114 @102 @612 +@696 := @636 @0 +@699 := @696 @606 @114 @102 +@713 := {c : @22} -> + {A : @23} -> + {f : @24} -> + {fn : @472} -> + {args : @98} -> + {env : @581} -> + {F : @555} -> + {o : @557} -> + (hB : @687) -> + (hfn : @691) -> (hwt : @695) -> (hbind : @625) -> (hF : @635) -> (hA : @699) -> @664 +@714 := @681 @1 +@715 := @682 @1 +@719 := (n : @24) -> @715 @108 @4 @100 +@722 := @88 @114 @102 @612 +@723 := @628 @1 +@726 := @627 (@723 @583) @634 +@727 := @653 @1 +@737 := (hbind : @625) -> + (hF : @726) -> (hA : @699) -> (hne : @643) -> @646 (fun (ro : @645) => @652 (@727 @657 @629 @4)) +@747 := {A : @23} -> + {f : @24} -> + {fn : @472} -> + {args : @98} -> + {env : @581} -> {F : @555} -> {o : @557} -> (hB : @719) -> (hfn : @691) -> (hwt : @722) -> @737 +@748 := @714 @2 +@750 := @715 @2 @4 +@752 := (n : @24) -> @750 @100 +@753 := @94 @102 +@754 := @753 @612 +@763 := {f : @24} -> + {fn : @472} -> + {args : @98} -> + {env : @581} -> {F : @555} -> {o : @557} -> (hB : @752) -> (hfn : @691) -> (hwt : @754) -> @737 +@764 := @748 @9 +@766 := (n : @24) -> @750 @9 +@767 := @688 @9 +@768 := @591 @767 +@769 := @768 @604 +@770 := @723 @9 +@771 := @627 @770 +@772 := @771 @634 +@773 := @696 @9 +@775 := @773 @114 @102 +@777 := @727 (@656 @9) +@785 := (hF : @772) -> (hA : @775) -> (hne : @643) -> @646 (fun (ro : @645) => @652 (@777 @629 @4)) +@794 := {fn : @472} -> + {args : @98} -> + {env : @581} -> + {F : @555} -> {o : @557} -> (hB : @766) -> (hfn : @769) -> (hwt : @754) -> (hbind : @625) -> @785 +@795 := @764 @490 +@797 := @768 (@603 @490) +@798 := @611 @490 +@799 := @753 @798 +@801 := @616 (@617 @490) +@813 := {args : @98} -> + {env : @581} -> + {F : @555} -> + {o : @557} -> + (hB : @766) -> (hfn : @797) -> (hwt : @799) -> (hbind : @615 (@801 @100 @465) @624) -> @785 +@814 := @795 @400 +@816 := @512 (@370 @61) +@818 := @94 @816 @798 +@820 := @62 (@18 @114) +@822 := @820 (@512 @61) +@826 := @615 (@801 @822 @465) @624 +@828 := @62 (@18 @606) +@830 := @62 (@18 @583) +@832 := @828 (@830 @61) +@834 := @773 @832 @102 +@836 := @62 (@18 @637) +@839 := @62 (@18 #12) +@856 := {env : @581} -> + {F : @555} -> + {o : @557} -> + (hB : @766) -> + (hfn : @797) -> + (hwt : @818) -> + (hbind : @826) -> + (hF : @772) -> + (hA : @834) -> (hne : @643) -> @646 (fun (ro : @645) => @652 (@777 (@836 (@839 @61)) @4)) +@857 := @814 @470 +@859 := @370 (@190 @61) +@861 := @94 @859 @798 +@872 := @615 (@801 @816 @465) (@623 (@466 (@461 @369) (@466 (@463 @511) @465))) +@874 := @830 (@820 @61) +@876 := @773 @874 @102 +@878 := @62 (@18 @629) +@894 := {F : @555} -> + {o : @557} -> + (hB : @766) -> + (hfn : @797) -> + (hwt : @861) -> + (hbind : @872) -> + (hF : @772) -> + (hA : @876) -> (hne : @643) -> @646 (fun (ro : @645) => @652 (@777 (@839 (@878 @61)) @4)) +@895 := @857 @471 +@896 := @531 @798 +@907 := @615 (@801 @859 @465) (@623 (@466 (@461 @189) (@466 (@463 @369) @465))) +@909 := @771 (@633 @471) +@911 := @773 @822 @102 +@912 := @648 @471 +@930 := {o : @557} -> + (hB : @766) -> + (hfn : @797) -> + (hwt : @896) -> + (hbind : @907) -> + (hF : @909) -> + (hA : @911) -> + (hne : @643) -> @646 (fun (ro : @645) => @647 (@912 @114 @4) (@777 (@878 (@828 @61)) @4)) +@931 := @895 @544 +@932 := @388 @798 +@943 := @615 (@801 @530 @465) (@623 (@466 (@461 @203) (@466 (@463 @189) @465))) +@944 := @773 @816 +@946 := @542 @108 @100 +@947 := @944 @946 +@949 := @542 @114 @108 +@968 := (hB : @766) -> + (hfn : @797) -> + (hwt : @932) -> + (hbind : @943) -> + (hF : @909) -> + (hA : @947) -> + (hne : @558 @949 @563) -> @646 (fun (ro : @645) => @647 (@912 (@542 @606 @583) @4) (@777 @832 @4)) +@969 := @931 @494 +@970 := @395 @798 +@981 := @615 (@801 @387 @465) (@623 (@466 (@461 @186) (@466 (@463 @203) @465))) +@982 := @773 @859 +@984 := @542 @100 @102 +@1003 := (hfn : @797) -> + (hwt : @970) -> + (hbind : @981) -> + (hF : @909) -> + (hA : @982 @984) -> + (hne : @558 @946 @563) -> @646 (fun (ro : @645) => @647 (@912 (@542 @583 @114) @4) (@777 @874 @4)) +@1006 := @969 (@350 @590 @767) +@1007 := @401 @798 +@1018 := @615 (@801 @394 @465) (@623 (@466 (@461 @200) (@466 (@463 @186) @465))) +@1019 := @773 @530 +@1021 := @542 @102 @104 +@1037 := (hwt : @1007) -> + (hbind : @1018) -> + (hF : @909) -> + (hA : @1019 @1021) -> + (hne : @558 @984 @563) -> @646 (fun (ro : @645) => @647 (@912 @949 @4) (@777 @822 @4)) +@1038 := @1006 @541 +@1040 := @801 @400 @465 +@1043 := @615 @1040 (@623 @470) +@1044 := @773 @387 +@1046 := @542 @104 @25 +@1061 := (hbind : @1043) -> + (hF : @909) -> + (hA : @1044 @1046) -> + (hne : @558 @1021 @563) -> @646 (fun (ro : @645) => @647 (@912 @946 @4) (@777 @816 @4)) +@1064 := @1038 (@350 @614 @1040) +@1065 := @773 @394 +@1067 := @542 @25 @27 +@1081 := (hF : @909) -> + (hA : @1065 @1067) -> + (hne : @558 @1046 @563) -> @646 (fun (ro : @645) => @647 (@912 @984 @4) (@777 @859 @4)) +@1084 := @1064 (@350 @626 @770) +@1098 := (hA : @773 @400 @544) -> + (hne : @558 @1067 @563) -> @646 (fun (ro : @645) => @647 (@912 @1021 @4) (@777 @530 @4)) +@1099 := @1084 @554 +@1110 := (hne : @558 @544 @563) -> @646 (fun (ro : @645) => @647 (@912 @1046 @4) (@777 @387 @4)) +@1111 := @1099 @576 +@1117 := @647 (@912 @1067 @4) (@777 @394 @4) +@1119 := @646 (fun (ro : @645) => @1117) +@1121 := @646 (fun (__e_ro : @645) => @1117) +@1123 := LexLeanPreservation.Rust.RepresentableL @364 +@1124 := (__e_hrep : @1123) -> @1121 +@1125 := fun (__e_hrep : @1123) => @1111 +@1126 := (height : @24) -> @1124 +@1127 := fun (height : @24) => @1125 +@1128 := (width : @24) -> @1126 +@1129 := fun (width : @24) => @1127 +\end{coremodule} +\end{lexlean} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustCore.lean deleted file mode 100644 index 1903d2a62..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2 -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (value : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat value)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.denote value) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat value)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat value) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.root value) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustCore.lex.tex new file mode 100644 index 000000000..7139c993c --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustCore.lex.tex @@ -0,0 +1,417 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2, + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore.root : @825 := @826 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore.program +@1 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore.krate +@2 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore.flags +@3 := Nat +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@59 := Prod.{0, 0} @3 @50 +@60 := 0 +@64 := Prod.mk.{0, 0} @3 @50 @60 +@65 := @64 @6 +@66 := @51 @59 +@67 := @52 @59 +@69 := @67 @65 @66 +@70 := Bool.true +@71 := LexLeanTarget.TargetSyntax.Function +@72 := LexLeanTarget.TargetSyntax.Program.functions +@73 := @72 @0 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := @51 @3 +@76 := @51 @74 +@77 := LexLeanTarget.TargetSyntax.Ty.unit +@78 := LexLeanTarget.TargetSyntax.Value.unit +@81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 +@86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 +@91 := List.getD.{0} @71 @73 @60 @86 +@95 := fun (__e_n : @3) => + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore.root @17 @60 +@96 := LexLeanPreservation.Rust.WTL +@104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 +@106 := LexLeanPreservation.Rust.wtl_nil @0 +@107 := @96 @0 +@113 := {c : @9} -> {A : @10} -> @107 @4 @17 @53 @76 +@114 := @106 @1 +@115 := @107 @1 +@119 := {A : @10} -> @115 @17 @53 @76 +@120 := @114 @2 +@121 := @115 @2 +@122 := @121 @53 +@123 := @122 @76 +@124 := List.{0} +@125 := @124 @50 +@126 := @124 @74 +@127 := #6 +@128 := @11 @127 +@129 := #5 +@130 := @128 @129 +@131 := #4 +@134 := @130 @131 @12 @14 +@135 := #7 +@140 := @96 @135 @127 @129 @14 @4 +@141 := #8 +@144 := @96 @141 @135 @127 +@146 := @54 @129 @12 +@147 := @144 @146 +@148 := @52 @74 +@150 := @148 @131 @14 +@160 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @134) -> (hs : @140) -> @147 @150 +@162 := LexLeanPreservation.Rust.wtl_cons @0 +@182 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> + (h : @27 @129 @131 @12 @14) -> (hs : @107 @127 @129 @14 @4) -> @107 @135 @127 @146 @150 +@183 := @162 @1 +@199 := {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> (h : @36 @131 @12 @14) -> (hs : @115 @129 @14 @4) -> @115 @127 @146 @150 +@200 := @183 @2 +@202 := @43 @12 @14 +@204 := @121 @14 @4 +@212 := {v : @50} -> + {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @202) -> (hs : @204) -> @121 @146 @150 +@213 := @200 @6 +@214 := @5 @131 +@216 := @43 @214 @14 +@217 := @5 @127 +@218 := @54 @217 +@226 := {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @216) -> (hs : @204) -> @121 (@218 @12) @150 +@227 := @213 @7 +@228 := @5 @12 +@230 := @43 @228 @7 +@231 := @5 @129 +@232 := @54 @231 +@234 := @121 (@232 @12) +@235 := @148 @7 +@236 := @235 @14 +@241 := {vs : @125} -> {ts : @126} -> (h : @230) -> (hs : @204) -> @234 @236 +@242 := @227 @53 +@243 := @5 @14 +@245 := @43 @243 @7 +@246 := @122 @4 +@248 := @54 @214 @53 +@249 := @121 @248 +@253 := {ts : @126} -> (h : @245) -> (hs : @246) -> @249 @236 +@254 := @242 @76 +@256 := @54 @228 @53 +@257 := @121 @256 +@258 := @235 @76 +@261 := (h : @49) -> (hs : @123) -> @257 @258 +@262 := @254 @47 +@264 := @54 @243 @53 +@265 := @121 @264 +@267 := (hs : @123) -> @265 @258 +@268 := @262 @120 +@269 := @121 @56 +@270 := @269 @258 +@271 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.__fits_0 +@274 := @273 @4 +@277 := @5 (Production.Main.quadruple @4) +@279 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.root @4 +@280 := Bool +@281 := Ne.{1} +@282 := LexLeanPreservation.Obs +@283 := @281 @282 +@284 := LexLeanPreservation.Rel +@287 := @283 (@284 @4 @17) +@288 := LexLeanPreservation.Obs.stuck +@291 := (f : @280) -> (v : @50) -> @287 @288 +@293 := LexLeanPreservation.Rust.rel_ne_stuck @274 +@299 := (v : @50) -> @283 (@284 (@273 @14) @17) @288 +@300 := @293 @277 +@304 := @283 (@284 @274 @277) @288 +@305 := @124 @59 +@306 := LexLeanPreservation.Rust.FunSem +@307 := #9 +@313 := (n : @3) -> @306 @307 @141 @135 @17 @127 +@314 := Eq.{1} +@315 := Option.{0} +@316 := @315 @71 +@317 := @314 @316 +@324 := LexLeanRuntime.index (@124 @71) @71 (LexLeanRuntime.instIndexableList @71) +@328 := @317 (@324 (@72 @307) @127) +@329 := Option.some.{0} +@330 := @329 @71 +@331 := @330 @129 +@332 := @328 @331 +@333 := #10 +@337 := @96 @333 @307 @141 @129 +@338 := LexLeanTarget.TargetSyntax.Function.types +@339 := @338 @127 +@340 := @337 @339 +@341 := @315 @305 +@342 := @314 @341 +@343 := LexLeanTarget.TargetSemantics.bindAll +@344 := LexLeanTarget.TargetSyntax.Function.parameters +@349 := @342 (@343 (@344 @135) @127 @66) +@350 := @329 @305 +@351 := @350 @129 +@352 := @349 @351 +@353 := @315 @280 +@354 := @314 @353 +@355 := LexLeanPreservation.Rust.fnFallible +@356 := #11 +@359 := @354 (@355 @356 @307) +@360 := @329 @280 +@361 := @360 @129 +@362 := @359 @361 +@363 := LexLeanPreservation.RunConv +@364 := #13 +@368 := @363 @364 @333 @141 @129 +@370 := @283 @127 @288 +@371 := Exists.{1} +@372 := LexLeanPreservation.Rust.ROut +@373 := @371 @372 +@374 := And +@375 := LexLeanPreservation.Rust.RealizesFn +@379 := @374 (@375 @307 @141 @17) +@380 := LexLeanPreservation.Rust.RCI +@382 := @380 #15 +@383 := LexLeanPreservation.Rust.fnIdent +@384 := @383 @364 +@391 := (hne : @370) -> @373 (fun (ro : @372) => @379 (@382 @384 @356 @17)) +@406 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @313) -> + (hfn : @332) -> (hwt : @340) -> (hbind : @352) -> (hF : @362) -> (hA : @368) -> @391 +@408 := LexLeanPreservation.Rust.compose @0 +@409 := @306 @0 +@414 := (n : @3) -> @409 @141 @135 @17 @127 +@415 := @324 @73 +@418 := @317 (@415 @127) @331 +@422 := @107 @307 @141 @129 @339 +@423 := @363 @0 +@426 := @423 @333 @141 @129 +@440 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @414) -> + (hfn : @418) -> (hwt : @422) -> (hbind : @352) -> (hF : @362) -> (hA : @426) -> @391 +@441 := @408 @1 +@442 := @409 @1 +@446 := (n : @3) -> @442 @135 @17 @127 +@449 := @115 @141 @129 @339 +@450 := @355 @1 +@453 := @354 (@450 @307) @361 +@454 := @380 @1 +@464 := (hbind : @352) -> + (hF : @453) -> (hA : @426) -> (hne : @370) -> @373 (fun (ro : @372) => @379 (@454 @384 @356 @17)) +@474 := {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> {F : @280} -> {o : @282} -> (hB : @446) -> (hfn : @418) -> (hwt : @449) -> @464 +@475 := @441 @2 +@477 := @442 @2 @17 +@479 := (n : @3) -> @477 @127 +@480 := @121 @129 +@481 := @480 @339 +@490 := {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> {F : @280} -> {o : @282} -> (hB : @479) -> (hfn : @418) -> (hwt : @481) -> @464 +@491 := @475 @60 +@493 := (n : @3) -> @477 @60 +@494 := @415 @60 +@495 := @317 @494 +@496 := @495 @331 +@497 := @450 @60 +@498 := @354 @497 +@499 := @498 @361 +@500 := @423 @60 +@502 := @500 @141 @129 +@504 := @454 (@383 @60) +@512 := (hF : @499) -> (hA : @502) -> (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 @356 @17)) +@521 := {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> {o : @282} -> (hB : @493) -> (hfn : @496) -> (hwt : @481) -> (hbind : @352) -> @512 +@522 := @491 @91 +@524 := @495 (@330 @91) +@525 := @338 @91 +@526 := @480 @525 +@528 := @343 (@344 @91) +@540 := {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @493) -> (hfn : @524) -> (hwt : @526) -> (hbind : @342 (@528 @127 @66) @351) -> @512 +@541 := @522 @56 +@542 := @218 @53 +@544 := @121 @542 @525 +@547 := @54 (@5 @135) @53 +@551 := @342 (@528 @547 @66) @351 +@554 := @54 (@5 @307) @53 +@575 := {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @544) -> + (hbind : @551) -> + (hF : @499) -> + (hA : @500 @554 @129) -> + (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 (@54 (@5 #12) @53) @17)) +@576 := @541 @69 +@577 := @232 @53 +@579 := @121 @577 @525 +@587 := @342 (@528 @542 @66) (@350 (@67 (@64 @217) @66)) +@590 := @54 (@5 @141) @53 +@609 := {F : @280} -> + {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @579) -> + (hbind : @587) -> + (hF : @499) -> + (hA : @500 @590 @129) -> + (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 (@54 (@5 @356) @53) @17)) +@610 := @576 @70 +@611 := @249 @525 +@619 := @342 (@528 @577 @66) (@350 (@67 (@64 @231) @66)) +@621 := @498 (@360 @70) +@623 := @500 @547 @129 +@624 := @375 @70 +@643 := {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @611) -> + (hbind : @619) -> + (hF : @621) -> + (hA : @623) -> + (hne : @370) -> @373 (fun (ro : @372) => @374 (@624 @141 @17) (@504 (@54 (@5 @333) @53) @17)) +@644 := @610 @272 +@645 := @257 @525 +@653 := @342 (@528 @248 @66) (@350 (@67 (@64 @214) @66)) +@654 := @500 @542 +@655 := @271 @127 +@656 := @654 @655 +@657 := @271 @135 +@675 := (hB : @493) -> + (hfn : @524) -> + (hwt : @645) -> + (hbind : @653) -> + (hF : @621) -> + (hA : @656) -> + (hne : @283 @657 @288) -> @373 (fun (ro : @372) => @374 (@624 (@271 @307) @17) (@504 @554 @17)) +@676 := @644 @95 +@677 := @265 @525 +@685 := @342 (@528 @256 @66) (@350 (@67 (@64 @228) @66)) +@686 := @500 @577 +@687 := @271 @129 +@705 := (hfn : @524) -> + (hwt : @677) -> + (hbind : @685) -> + (hF : @621) -> + (hA : @686 @687) -> + (hne : @283 @655 @288) -> @373 (fun (ro : @372) => @374 (@624 (@271 @141) @17) (@504 @590 @17)) +@706 := Eq.refl.{1} +@709 := @676 (@706 @316 @494) +@710 := @269 @525 +@718 := @342 (@528 @264 @66) (@350 (@67 (@64 @243) @66)) +@719 := @500 @248 +@720 := @271 @131 +@736 := (hwt : @710) -> + (hbind : @718) -> + (hF : @621) -> + (hA : @719 @720) -> + (hne : @283 @687 @288) -> @373 (fun (ro : @372) => @374 (@624 @657 @17) (@504 @547 @17)) +@737 := @709 @268 +@739 := @528 @56 @66 +@742 := @342 @739 (@350 @69) +@743 := @500 @256 +@744 := @271 @12 +@759 := (hbind : @742) -> + (hF : @621) -> + (hA : @743 @744) -> + (hne : @283 @720 @288) -> @373 (fun (ro : @372) => @374 (@624 @655 @17) (@504 @542 @17)) +@762 := @737 (@706 @341 @739) +@763 := @500 @264 +@764 := @271 @14 +@778 := (hF : @621) -> + (hA : @763 @764) -> + (hne : @283 @744 @288) -> @373 (fun (ro : @372) => @374 (@624 @687 @17) (@504 @577 @17)) +@781 := @762 (@706 @353 @497) +@795 := (hA : @500 @56 @272) -> + (hne : @283 @764 @288) -> @373 (fun (ro : @372) => @374 (@624 @720 @17) (@504 @248 @17)) +@796 := @781 @279 +@807 := (hne : @283 @272 @288) -> @373 (fun (ro : @372) => @374 (@624 @744 @17) (@504 @256 @17)) +@808 := @796 @300 +@814 := @374 (@624 @764 @17) (@504 @264 @17) +@816 := @373 (fun (ro : @372) => @814) +@818 := @373 (fun (__e_ro : @372) => @814) +@822 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@823 := (__e_hrep : @822) -> @818 +@824 := fun (__e_hrep : @822) => @808 +@825 := (value : @3) -> @823 +@826 := fun (value : @3) => @824 +\end{coremodule} +\end{lexlean} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustStd.lean deleted file mode 100644 index 29d181938..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2 -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (value : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat value)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.denote value) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat value)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat value) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.root value) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustStd.lex.tex new file mode 100644 index 000000000..6e6d6649d --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustStd.lex.tex @@ -0,0 +1,416 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2, + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd.root : @825 := @826 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd.program +@1 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd.krate +@2 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd.flags +@3 := Nat +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@59 := Prod.{0, 0} @3 @50 +@60 := 0 +@64 := Prod.mk.{0, 0} @3 @50 @60 +@65 := @64 @6 +@66 := @51 @59 +@67 := @52 @59 +@69 := @67 @65 @66 +@70 := Bool.true +@71 := LexLeanTarget.TargetSyntax.Function +@72 := LexLeanTarget.TargetSyntax.Program.functions +@73 := @72 @0 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := @51 @3 +@76 := @51 @74 +@77 := LexLeanTarget.TargetSyntax.Ty.unit +@78 := LexLeanTarget.TargetSyntax.Value.unit +@81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 +@86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 +@91 := List.getD.{0} @71 @73 @60 @86 +@95 := fun (__e_n : @3) => LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd.root @17 @60 +@96 := LexLeanPreservation.Rust.WTL +@104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 +@106 := LexLeanPreservation.Rust.wtl_nil @0 +@107 := @96 @0 +@113 := {c : @9} -> {A : @10} -> @107 @4 @17 @53 @76 +@114 := @106 @1 +@115 := @107 @1 +@119 := {A : @10} -> @115 @17 @53 @76 +@120 := @114 @2 +@121 := @115 @2 +@122 := @121 @53 +@123 := @122 @76 +@124 := List.{0} +@125 := @124 @50 +@126 := @124 @74 +@127 := #6 +@128 := @11 @127 +@129 := #5 +@130 := @128 @129 +@131 := #4 +@134 := @130 @131 @12 @14 +@135 := #7 +@140 := @96 @135 @127 @129 @14 @4 +@141 := #8 +@144 := @96 @141 @135 @127 +@146 := @54 @129 @12 +@147 := @144 @146 +@148 := @52 @74 +@150 := @148 @131 @14 +@160 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @134) -> (hs : @140) -> @147 @150 +@162 := LexLeanPreservation.Rust.wtl_cons @0 +@182 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> + (h : @27 @129 @131 @12 @14) -> (hs : @107 @127 @129 @14 @4) -> @107 @135 @127 @146 @150 +@183 := @162 @1 +@199 := {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> (h : @36 @131 @12 @14) -> (hs : @115 @129 @14 @4) -> @115 @127 @146 @150 +@200 := @183 @2 +@202 := @43 @12 @14 +@204 := @121 @14 @4 +@212 := {v : @50} -> + {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @202) -> (hs : @204) -> @121 @146 @150 +@213 := @200 @6 +@214 := @5 @131 +@216 := @43 @214 @14 +@217 := @5 @127 +@218 := @54 @217 +@226 := {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @216) -> (hs : @204) -> @121 (@218 @12) @150 +@227 := @213 @7 +@228 := @5 @12 +@230 := @43 @228 @7 +@231 := @5 @129 +@232 := @54 @231 +@234 := @121 (@232 @12) +@235 := @148 @7 +@236 := @235 @14 +@241 := {vs : @125} -> {ts : @126} -> (h : @230) -> (hs : @204) -> @234 @236 +@242 := @227 @53 +@243 := @5 @14 +@245 := @43 @243 @7 +@246 := @122 @4 +@248 := @54 @214 @53 +@249 := @121 @248 +@253 := {ts : @126} -> (h : @245) -> (hs : @246) -> @249 @236 +@254 := @242 @76 +@256 := @54 @228 @53 +@257 := @121 @256 +@258 := @235 @76 +@261 := (h : @49) -> (hs : @123) -> @257 @258 +@262 := @254 @47 +@264 := @54 @243 @53 +@265 := @121 @264 +@267 := (hs : @123) -> @265 @258 +@268 := @262 @120 +@269 := @121 @56 +@270 := @269 @258 +@271 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.__fits_0 +@274 := @273 @4 +@277 := @5 (Production.Main.quadruple @4) +@279 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.root @4 +@280 := Bool +@281 := Ne.{1} +@282 := LexLeanPreservation.Obs +@283 := @281 @282 +@284 := LexLeanPreservation.Rel +@287 := @283 (@284 @4 @17) +@288 := LexLeanPreservation.Obs.stuck +@291 := (f : @280) -> (v : @50) -> @287 @288 +@293 := LexLeanPreservation.Rust.rel_ne_stuck @274 +@299 := (v : @50) -> @283 (@284 (@273 @14) @17) @288 +@300 := @293 @277 +@304 := @283 (@284 @274 @277) @288 +@305 := @124 @59 +@306 := LexLeanPreservation.Rust.FunSem +@307 := #9 +@313 := (n : @3) -> @306 @307 @141 @135 @17 @127 +@314 := Eq.{1} +@315 := Option.{0} +@316 := @315 @71 +@317 := @314 @316 +@324 := LexLeanRuntime.index (@124 @71) @71 (LexLeanRuntime.instIndexableList @71) +@328 := @317 (@324 (@72 @307) @127) +@329 := Option.some.{0} +@330 := @329 @71 +@331 := @330 @129 +@332 := @328 @331 +@333 := #10 +@337 := @96 @333 @307 @141 @129 +@338 := LexLeanTarget.TargetSyntax.Function.types +@339 := @338 @127 +@340 := @337 @339 +@341 := @315 @305 +@342 := @314 @341 +@343 := LexLeanTarget.TargetSemantics.bindAll +@344 := LexLeanTarget.TargetSyntax.Function.parameters +@349 := @342 (@343 (@344 @135) @127 @66) +@350 := @329 @305 +@351 := @350 @129 +@352 := @349 @351 +@353 := @315 @280 +@354 := @314 @353 +@355 := LexLeanPreservation.Rust.fnFallible +@356 := #11 +@359 := @354 (@355 @356 @307) +@360 := @329 @280 +@361 := @360 @129 +@362 := @359 @361 +@363 := LexLeanPreservation.RunConv +@364 := #13 +@368 := @363 @364 @333 @141 @129 +@370 := @283 @127 @288 +@371 := Exists.{1} +@372 := LexLeanPreservation.Rust.ROut +@373 := @371 @372 +@374 := And +@375 := LexLeanPreservation.Rust.RealizesFn +@379 := @374 (@375 @307 @141 @17) +@380 := LexLeanPreservation.Rust.RCI +@382 := @380 #15 +@383 := LexLeanPreservation.Rust.fnIdent +@384 := @383 @364 +@391 := (hne : @370) -> @373 (fun (ro : @372) => @379 (@382 @384 @356 @17)) +@406 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @313) -> + (hfn : @332) -> (hwt : @340) -> (hbind : @352) -> (hF : @362) -> (hA : @368) -> @391 +@408 := LexLeanPreservation.Rust.compose @0 +@409 := @306 @0 +@414 := (n : @3) -> @409 @141 @135 @17 @127 +@415 := @324 @73 +@418 := @317 (@415 @127) @331 +@422 := @107 @307 @141 @129 @339 +@423 := @363 @0 +@426 := @423 @333 @141 @129 +@440 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @414) -> + (hfn : @418) -> (hwt : @422) -> (hbind : @352) -> (hF : @362) -> (hA : @426) -> @391 +@441 := @408 @1 +@442 := @409 @1 +@446 := (n : @3) -> @442 @135 @17 @127 +@449 := @115 @141 @129 @339 +@450 := @355 @1 +@453 := @354 (@450 @307) @361 +@454 := @380 @1 +@464 := (hbind : @352) -> + (hF : @453) -> (hA : @426) -> (hne : @370) -> @373 (fun (ro : @372) => @379 (@454 @384 @356 @17)) +@474 := {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> {F : @280} -> {o : @282} -> (hB : @446) -> (hfn : @418) -> (hwt : @449) -> @464 +@475 := @441 @2 +@477 := @442 @2 @17 +@479 := (n : @3) -> @477 @127 +@480 := @121 @129 +@481 := @480 @339 +@490 := {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> {F : @280} -> {o : @282} -> (hB : @479) -> (hfn : @418) -> (hwt : @481) -> @464 +@491 := @475 @60 +@493 := (n : @3) -> @477 @60 +@494 := @415 @60 +@495 := @317 @494 +@496 := @495 @331 +@497 := @450 @60 +@498 := @354 @497 +@499 := @498 @361 +@500 := @423 @60 +@502 := @500 @141 @129 +@504 := @454 (@383 @60) +@512 := (hF : @499) -> (hA : @502) -> (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 @356 @17)) +@521 := {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> {o : @282} -> (hB : @493) -> (hfn : @496) -> (hwt : @481) -> (hbind : @352) -> @512 +@522 := @491 @91 +@524 := @495 (@330 @91) +@525 := @338 @91 +@526 := @480 @525 +@528 := @343 (@344 @91) +@540 := {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @493) -> (hfn : @524) -> (hwt : @526) -> (hbind : @342 (@528 @127 @66) @351) -> @512 +@541 := @522 @56 +@542 := @218 @53 +@544 := @121 @542 @525 +@547 := @54 (@5 @135) @53 +@551 := @342 (@528 @547 @66) @351 +@554 := @54 (@5 @307) @53 +@575 := {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @544) -> + (hbind : @551) -> + (hF : @499) -> + (hA : @500 @554 @129) -> + (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 (@54 (@5 #12) @53) @17)) +@576 := @541 @69 +@577 := @232 @53 +@579 := @121 @577 @525 +@587 := @342 (@528 @542 @66) (@350 (@67 (@64 @217) @66)) +@590 := @54 (@5 @141) @53 +@609 := {F : @280} -> + {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @579) -> + (hbind : @587) -> + (hF : @499) -> + (hA : @500 @590 @129) -> + (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 (@54 (@5 @356) @53) @17)) +@610 := @576 @70 +@611 := @249 @525 +@619 := @342 (@528 @577 @66) (@350 (@67 (@64 @231) @66)) +@621 := @498 (@360 @70) +@623 := @500 @547 @129 +@624 := @375 @70 +@643 := {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @611) -> + (hbind : @619) -> + (hF : @621) -> + (hA : @623) -> + (hne : @370) -> @373 (fun (ro : @372) => @374 (@624 @141 @17) (@504 (@54 (@5 @333) @53) @17)) +@644 := @610 @272 +@645 := @257 @525 +@653 := @342 (@528 @248 @66) (@350 (@67 (@64 @214) @66)) +@654 := @500 @542 +@655 := @271 @127 +@656 := @654 @655 +@657 := @271 @135 +@675 := (hB : @493) -> + (hfn : @524) -> + (hwt : @645) -> + (hbind : @653) -> + (hF : @621) -> + (hA : @656) -> + (hne : @283 @657 @288) -> @373 (fun (ro : @372) => @374 (@624 (@271 @307) @17) (@504 @554 @17)) +@676 := @644 @95 +@677 := @265 @525 +@685 := @342 (@528 @256 @66) (@350 (@67 (@64 @228) @66)) +@686 := @500 @577 +@687 := @271 @129 +@705 := (hfn : @524) -> + (hwt : @677) -> + (hbind : @685) -> + (hF : @621) -> + (hA : @686 @687) -> + (hne : @283 @655 @288) -> @373 (fun (ro : @372) => @374 (@624 (@271 @141) @17) (@504 @590 @17)) +@706 := Eq.refl.{1} +@709 := @676 (@706 @316 @494) +@710 := @269 @525 +@718 := @342 (@528 @264 @66) (@350 (@67 (@64 @243) @66)) +@719 := @500 @248 +@720 := @271 @131 +@736 := (hwt : @710) -> + (hbind : @718) -> + (hF : @621) -> + (hA : @719 @720) -> + (hne : @283 @687 @288) -> @373 (fun (ro : @372) => @374 (@624 @657 @17) (@504 @547 @17)) +@737 := @709 @268 +@739 := @528 @56 @66 +@742 := @342 @739 (@350 @69) +@743 := @500 @256 +@744 := @271 @12 +@759 := (hbind : @742) -> + (hF : @621) -> + (hA : @743 @744) -> + (hne : @283 @720 @288) -> @373 (fun (ro : @372) => @374 (@624 @655 @17) (@504 @542 @17)) +@762 := @737 (@706 @341 @739) +@763 := @500 @264 +@764 := @271 @14 +@778 := (hF : @621) -> + (hA : @763 @764) -> + (hne : @283 @744 @288) -> @373 (fun (ro : @372) => @374 (@624 @687 @17) (@504 @577 @17)) +@781 := @762 (@706 @353 @497) +@795 := (hA : @500 @56 @272) -> + (hne : @283 @764 @288) -> @373 (fun (ro : @372) => @374 (@624 @720 @17) (@504 @248 @17)) +@796 := @781 @279 +@807 := (hne : @283 @272 @288) -> @373 (fun (ro : @372) => @374 (@624 @744 @17) (@504 @256 @17)) +@808 := @796 @300 +@814 := @374 (@624 @764 @17) (@504 @264 @17) +@816 := @373 (fun (ro : @372) => @814) +@818 := @373 (fun (__e_ro : @372) => @814) +@822 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@823 := (__e_hrep : @822) -> @818 +@824 := fun (__e_hrep : @822) => @808 +@825 := (value : @3) -> @823 +@826 := fun (value : @3) => @824 +\end{coremodule} +\end{lexlean} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustCore.lean deleted file mode 100644 index bfb93ff29..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3 -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (number : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat number)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.denote number) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat number)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat number) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.root number) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustCore.lex.tex new file mode 100644 index 000000000..47be11214 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustCore.lex.tex @@ -0,0 +1,417 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3, + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore.root : @825 := @826 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore.program +@1 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore.krate +@2 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore.flags +@3 := Nat +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@59 := Prod.{0, 0} @3 @50 +@60 := 0 +@64 := Prod.mk.{0, 0} @3 @50 @60 +@65 := @64 @6 +@66 := @51 @59 +@67 := @52 @59 +@69 := @67 @65 @66 +@70 := Bool.true +@71 := LexLeanTarget.TargetSyntax.Function +@72 := LexLeanTarget.TargetSyntax.Program.functions +@73 := @72 @0 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := @51 @3 +@76 := @51 @74 +@77 := LexLeanTarget.TargetSyntax.Ty.unit +@78 := LexLeanTarget.TargetSyntax.Value.unit +@81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 +@86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 +@91 := List.getD.{0} @71 @73 @60 @86 +@95 := fun (__e_n : @3) => + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore.root @17 @60 +@96 := LexLeanPreservation.Rust.WTL +@104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 +@106 := LexLeanPreservation.Rust.wtl_nil @0 +@107 := @96 @0 +@113 := {c : @9} -> {A : @10} -> @107 @4 @17 @53 @76 +@114 := @106 @1 +@115 := @107 @1 +@119 := {A : @10} -> @115 @17 @53 @76 +@120 := @114 @2 +@121 := @115 @2 +@122 := @121 @53 +@123 := @122 @76 +@124 := List.{0} +@125 := @124 @50 +@126 := @124 @74 +@127 := #6 +@128 := @11 @127 +@129 := #5 +@130 := @128 @129 +@131 := #4 +@134 := @130 @131 @12 @14 +@135 := #7 +@140 := @96 @135 @127 @129 @14 @4 +@141 := #8 +@144 := @96 @141 @135 @127 +@146 := @54 @129 @12 +@147 := @144 @146 +@148 := @52 @74 +@150 := @148 @131 @14 +@160 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @134) -> (hs : @140) -> @147 @150 +@162 := LexLeanPreservation.Rust.wtl_cons @0 +@182 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> + (h : @27 @129 @131 @12 @14) -> (hs : @107 @127 @129 @14 @4) -> @107 @135 @127 @146 @150 +@183 := @162 @1 +@199 := {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> (h : @36 @131 @12 @14) -> (hs : @115 @129 @14 @4) -> @115 @127 @146 @150 +@200 := @183 @2 +@202 := @43 @12 @14 +@204 := @121 @14 @4 +@212 := {v : @50} -> + {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @202) -> (hs : @204) -> @121 @146 @150 +@213 := @200 @6 +@214 := @5 @131 +@216 := @43 @214 @14 +@217 := @5 @127 +@218 := @54 @217 +@226 := {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @216) -> (hs : @204) -> @121 (@218 @12) @150 +@227 := @213 @7 +@228 := @5 @12 +@230 := @43 @228 @7 +@231 := @5 @129 +@232 := @54 @231 +@234 := @121 (@232 @12) +@235 := @148 @7 +@236 := @235 @14 +@241 := {vs : @125} -> {ts : @126} -> (h : @230) -> (hs : @204) -> @234 @236 +@242 := @227 @53 +@243 := @5 @14 +@245 := @43 @243 @7 +@246 := @122 @4 +@248 := @54 @214 @53 +@249 := @121 @248 +@253 := {ts : @126} -> (h : @245) -> (hs : @246) -> @249 @236 +@254 := @242 @76 +@256 := @54 @228 @53 +@257 := @121 @256 +@258 := @235 @76 +@261 := (h : @49) -> (hs : @123) -> @257 @258 +@262 := @254 @47 +@264 := @54 @243 @53 +@265 := @121 @264 +@267 := (hs : @123) -> @265 @258 +@268 := @262 @120 +@269 := @121 @56 +@270 := @269 @258 +@271 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.__fits_0 +@274 := @273 @4 +@277 := @5 (Production.Main.halvings @4) +@279 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.root @4 +@280 := Bool +@281 := Ne.{1} +@282 := LexLeanPreservation.Obs +@283 := @281 @282 +@284 := LexLeanPreservation.Rel +@287 := @283 (@284 @4 @17) +@288 := LexLeanPreservation.Obs.stuck +@291 := (f : @280) -> (v : @50) -> @287 @288 +@293 := LexLeanPreservation.Rust.rel_ne_stuck @274 +@299 := (v : @50) -> @283 (@284 (@273 @14) @17) @288 +@300 := @293 @277 +@304 := @283 (@284 @274 @277) @288 +@305 := @124 @59 +@306 := LexLeanPreservation.Rust.FunSem +@307 := #9 +@313 := (n : @3) -> @306 @307 @141 @135 @17 @127 +@314 := Eq.{1} +@315 := Option.{0} +@316 := @315 @71 +@317 := @314 @316 +@324 := LexLeanRuntime.index (@124 @71) @71 (LexLeanRuntime.instIndexableList @71) +@328 := @317 (@324 (@72 @307) @127) +@329 := Option.some.{0} +@330 := @329 @71 +@331 := @330 @129 +@332 := @328 @331 +@333 := #10 +@337 := @96 @333 @307 @141 @129 +@338 := LexLeanTarget.TargetSyntax.Function.types +@339 := @338 @127 +@340 := @337 @339 +@341 := @315 @305 +@342 := @314 @341 +@343 := LexLeanTarget.TargetSemantics.bindAll +@344 := LexLeanTarget.TargetSyntax.Function.parameters +@349 := @342 (@343 (@344 @135) @127 @66) +@350 := @329 @305 +@351 := @350 @129 +@352 := @349 @351 +@353 := @315 @280 +@354 := @314 @353 +@355 := LexLeanPreservation.Rust.fnFallible +@356 := #11 +@359 := @354 (@355 @356 @307) +@360 := @329 @280 +@361 := @360 @129 +@362 := @359 @361 +@363 := LexLeanPreservation.RunConv +@364 := #13 +@368 := @363 @364 @333 @141 @129 +@370 := @283 @127 @288 +@371 := Exists.{1} +@372 := LexLeanPreservation.Rust.ROut +@373 := @371 @372 +@374 := And +@375 := LexLeanPreservation.Rust.RealizesFn +@379 := @374 (@375 @307 @141 @17) +@380 := LexLeanPreservation.Rust.RCI +@382 := @380 #15 +@383 := LexLeanPreservation.Rust.fnIdent +@384 := @383 @364 +@391 := (hne : @370) -> @373 (fun (ro : @372) => @379 (@382 @384 @356 @17)) +@406 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @313) -> + (hfn : @332) -> (hwt : @340) -> (hbind : @352) -> (hF : @362) -> (hA : @368) -> @391 +@408 := LexLeanPreservation.Rust.compose @0 +@409 := @306 @0 +@414 := (n : @3) -> @409 @141 @135 @17 @127 +@415 := @324 @73 +@418 := @317 (@415 @127) @331 +@422 := @107 @307 @141 @129 @339 +@423 := @363 @0 +@426 := @423 @333 @141 @129 +@440 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @414) -> + (hfn : @418) -> (hwt : @422) -> (hbind : @352) -> (hF : @362) -> (hA : @426) -> @391 +@441 := @408 @1 +@442 := @409 @1 +@446 := (n : @3) -> @442 @135 @17 @127 +@449 := @115 @141 @129 @339 +@450 := @355 @1 +@453 := @354 (@450 @307) @361 +@454 := @380 @1 +@464 := (hbind : @352) -> + (hF : @453) -> (hA : @426) -> (hne : @370) -> @373 (fun (ro : @372) => @379 (@454 @384 @356 @17)) +@474 := {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> {F : @280} -> {o : @282} -> (hB : @446) -> (hfn : @418) -> (hwt : @449) -> @464 +@475 := @441 @2 +@477 := @442 @2 @17 +@479 := (n : @3) -> @477 @127 +@480 := @121 @129 +@481 := @480 @339 +@490 := {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> {F : @280} -> {o : @282} -> (hB : @479) -> (hfn : @418) -> (hwt : @481) -> @464 +@491 := @475 @60 +@493 := (n : @3) -> @477 @60 +@494 := @415 @60 +@495 := @317 @494 +@496 := @495 @331 +@497 := @450 @60 +@498 := @354 @497 +@499 := @498 @361 +@500 := @423 @60 +@502 := @500 @141 @129 +@504 := @454 (@383 @60) +@512 := (hF : @499) -> (hA : @502) -> (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 @356 @17)) +@521 := {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> {o : @282} -> (hB : @493) -> (hfn : @496) -> (hwt : @481) -> (hbind : @352) -> @512 +@522 := @491 @91 +@524 := @495 (@330 @91) +@525 := @338 @91 +@526 := @480 @525 +@528 := @343 (@344 @91) +@540 := {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @493) -> (hfn : @524) -> (hwt : @526) -> (hbind : @342 (@528 @127 @66) @351) -> @512 +@541 := @522 @56 +@542 := @218 @53 +@544 := @121 @542 @525 +@547 := @54 (@5 @135) @53 +@551 := @342 (@528 @547 @66) @351 +@554 := @54 (@5 @307) @53 +@575 := {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @544) -> + (hbind : @551) -> + (hF : @499) -> + (hA : @500 @554 @129) -> + (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 (@54 (@5 #12) @53) @17)) +@576 := @541 @69 +@577 := @232 @53 +@579 := @121 @577 @525 +@587 := @342 (@528 @542 @66) (@350 (@67 (@64 @217) @66)) +@590 := @54 (@5 @141) @53 +@609 := {F : @280} -> + {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @579) -> + (hbind : @587) -> + (hF : @499) -> + (hA : @500 @590 @129) -> + (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 (@54 (@5 @356) @53) @17)) +@610 := @576 @70 +@611 := @249 @525 +@619 := @342 (@528 @577 @66) (@350 (@67 (@64 @231) @66)) +@621 := @498 (@360 @70) +@623 := @500 @547 @129 +@624 := @375 @70 +@643 := {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @611) -> + (hbind : @619) -> + (hF : @621) -> + (hA : @623) -> + (hne : @370) -> @373 (fun (ro : @372) => @374 (@624 @141 @17) (@504 (@54 (@5 @333) @53) @17)) +@644 := @610 @272 +@645 := @257 @525 +@653 := @342 (@528 @248 @66) (@350 (@67 (@64 @214) @66)) +@654 := @500 @542 +@655 := @271 @127 +@656 := @654 @655 +@657 := @271 @135 +@675 := (hB : @493) -> + (hfn : @524) -> + (hwt : @645) -> + (hbind : @653) -> + (hF : @621) -> + (hA : @656) -> + (hne : @283 @657 @288) -> @373 (fun (ro : @372) => @374 (@624 (@271 @307) @17) (@504 @554 @17)) +@676 := @644 @95 +@677 := @265 @525 +@685 := @342 (@528 @256 @66) (@350 (@67 (@64 @228) @66)) +@686 := @500 @577 +@687 := @271 @129 +@705 := (hfn : @524) -> + (hwt : @677) -> + (hbind : @685) -> + (hF : @621) -> + (hA : @686 @687) -> + (hne : @283 @655 @288) -> @373 (fun (ro : @372) => @374 (@624 (@271 @141) @17) (@504 @590 @17)) +@706 := Eq.refl.{1} +@709 := @676 (@706 @316 @494) +@710 := @269 @525 +@718 := @342 (@528 @264 @66) (@350 (@67 (@64 @243) @66)) +@719 := @500 @248 +@720 := @271 @131 +@736 := (hwt : @710) -> + (hbind : @718) -> + (hF : @621) -> + (hA : @719 @720) -> + (hne : @283 @687 @288) -> @373 (fun (ro : @372) => @374 (@624 @657 @17) (@504 @547 @17)) +@737 := @709 @268 +@739 := @528 @56 @66 +@742 := @342 @739 (@350 @69) +@743 := @500 @256 +@744 := @271 @12 +@759 := (hbind : @742) -> + (hF : @621) -> + (hA : @743 @744) -> + (hne : @283 @720 @288) -> @373 (fun (ro : @372) => @374 (@624 @655 @17) (@504 @542 @17)) +@762 := @737 (@706 @341 @739) +@763 := @500 @264 +@764 := @271 @14 +@778 := (hF : @621) -> + (hA : @763 @764) -> + (hne : @283 @744 @288) -> @373 (fun (ro : @372) => @374 (@624 @687 @17) (@504 @577 @17)) +@781 := @762 (@706 @353 @497) +@795 := (hA : @500 @56 @272) -> + (hne : @283 @764 @288) -> @373 (fun (ro : @372) => @374 (@624 @720 @17) (@504 @248 @17)) +@796 := @781 @279 +@807 := (hne : @283 @272 @288) -> @373 (fun (ro : @372) => @374 (@624 @744 @17) (@504 @256 @17)) +@808 := @796 @300 +@814 := @374 (@624 @764 @17) (@504 @264 @17) +@816 := @373 (fun (ro : @372) => @814) +@818 := @373 (fun (__e_ro : @372) => @814) +@822 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@823 := (__e_hrep : @822) -> @818 +@824 := fun (__e_hrep : @822) => @808 +@825 := (number : @3) -> @823 +@826 := fun (number : @3) => @824 +\end{coremodule} +\end{lexlean} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustStd.lean deleted file mode 100644 index 18a8bfa92..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3 -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (number : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat number)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.denote number) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat number)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat number) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.root number) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustStd.lex.tex new file mode 100644 index 000000000..208230e1a --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustStd.lex.tex @@ -0,0 +1,416 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3, + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd.root : @825 := @826 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd.program +@1 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd.krate +@2 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd.flags +@3 := Nat +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.nat +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.nat +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (n : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_nat @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (n : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (n : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (n : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@59 := Prod.{0, 0} @3 @50 +@60 := 0 +@64 := Prod.mk.{0, 0} @3 @50 @60 +@65 := @64 @6 +@66 := @51 @59 +@67 := @52 @59 +@69 := @67 @65 @66 +@70 := Bool.true +@71 := LexLeanTarget.TargetSyntax.Function +@72 := LexLeanTarget.TargetSyntax.Program.functions +@73 := @72 @0 +@74 := LexLeanTarget.TargetSyntax.Ty +@75 := @51 @3 +@76 := @51 @74 +@77 := LexLeanTarget.TargetSyntax.Ty.unit +@78 := LexLeanTarget.TargetSyntax.Value.unit +@81 := LexLeanTarget.TargetSyntax.Expr.value @77 @78 +@86 := LexLeanTarget.TargetSyntax.Function.mk @75 @76 @77 @81 +@91 := List.getD.{0} @71 @73 @60 @86 +@95 := fun (__e_n : @3) => LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd.root @17 @60 +@96 := LexLeanPreservation.Rust.WTL +@104 := {p : @8} -> {c : @9} -> {A : @10} -> @96 @14 @4 @17 @53 @76 +@106 := LexLeanPreservation.Rust.wtl_nil @0 +@107 := @96 @0 +@113 := {c : @9} -> {A : @10} -> @107 @4 @17 @53 @76 +@114 := @106 @1 +@115 := @107 @1 +@119 := {A : @10} -> @115 @17 @53 @76 +@120 := @114 @2 +@121 := @115 @2 +@122 := @121 @53 +@123 := @122 @76 +@124 := List.{0} +@125 := @124 @50 +@126 := @124 @74 +@127 := #6 +@128 := @11 @127 +@129 := #5 +@130 := @128 @129 +@131 := #4 +@134 := @130 @131 @12 @14 +@135 := #7 +@140 := @96 @135 @127 @129 @14 @4 +@141 := #8 +@144 := @96 @141 @135 @127 +@146 := @54 @129 @12 +@147 := @144 @146 +@148 := @52 @74 +@150 := @148 @131 @14 +@160 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @134) -> (hs : @140) -> @147 @150 +@162 := LexLeanPreservation.Rust.wtl_cons @0 +@182 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> + (h : @27 @129 @131 @12 @14) -> (hs : @107 @127 @129 @14 @4) -> @107 @135 @127 @146 @150 +@183 := @162 @1 +@199 := {A : @10} -> + {v : @50} -> + {t : @74} -> + {vs : @125} -> + {ts : @126} -> (h : @36 @131 @12 @14) -> (hs : @115 @129 @14 @4) -> @115 @127 @146 @150 +@200 := @183 @2 +@202 := @43 @12 @14 +@204 := @121 @14 @4 +@212 := {v : @50} -> + {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @202) -> (hs : @204) -> @121 @146 @150 +@213 := @200 @6 +@214 := @5 @131 +@216 := @43 @214 @14 +@217 := @5 @127 +@218 := @54 @217 +@226 := {t : @74} -> {vs : @125} -> {ts : @126} -> (h : @216) -> (hs : @204) -> @121 (@218 @12) @150 +@227 := @213 @7 +@228 := @5 @12 +@230 := @43 @228 @7 +@231 := @5 @129 +@232 := @54 @231 +@234 := @121 (@232 @12) +@235 := @148 @7 +@236 := @235 @14 +@241 := {vs : @125} -> {ts : @126} -> (h : @230) -> (hs : @204) -> @234 @236 +@242 := @227 @53 +@243 := @5 @14 +@245 := @43 @243 @7 +@246 := @122 @4 +@248 := @54 @214 @53 +@249 := @121 @248 +@253 := {ts : @126} -> (h : @245) -> (hs : @246) -> @249 @236 +@254 := @242 @76 +@256 := @54 @228 @53 +@257 := @121 @256 +@258 := @235 @76 +@261 := (h : @49) -> (hs : @123) -> @257 @258 +@262 := @254 @47 +@264 := @54 @243 @53 +@265 := @121 @264 +@267 := (hs : @123) -> @265 @258 +@268 := @262 @120 +@269 := @121 @56 +@270 := @269 @258 +@271 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.__fits_0 +@274 := @273 @4 +@277 := @5 (Production.Main.halvings @4) +@279 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.root @4 +@280 := Bool +@281 := Ne.{1} +@282 := LexLeanPreservation.Obs +@283 := @281 @282 +@284 := LexLeanPreservation.Rel +@287 := @283 (@284 @4 @17) +@288 := LexLeanPreservation.Obs.stuck +@291 := (f : @280) -> (v : @50) -> @287 @288 +@293 := LexLeanPreservation.Rust.rel_ne_stuck @274 +@299 := (v : @50) -> @283 (@284 (@273 @14) @17) @288 +@300 := @293 @277 +@304 := @283 (@284 @274 @277) @288 +@305 := @124 @59 +@306 := LexLeanPreservation.Rust.FunSem +@307 := #9 +@313 := (n : @3) -> @306 @307 @141 @135 @17 @127 +@314 := Eq.{1} +@315 := Option.{0} +@316 := @315 @71 +@317 := @314 @316 +@324 := LexLeanRuntime.index (@124 @71) @71 (LexLeanRuntime.instIndexableList @71) +@328 := @317 (@324 (@72 @307) @127) +@329 := Option.some.{0} +@330 := @329 @71 +@331 := @330 @129 +@332 := @328 @331 +@333 := #10 +@337 := @96 @333 @307 @141 @129 +@338 := LexLeanTarget.TargetSyntax.Function.types +@339 := @338 @127 +@340 := @337 @339 +@341 := @315 @305 +@342 := @314 @341 +@343 := LexLeanTarget.TargetSemantics.bindAll +@344 := LexLeanTarget.TargetSyntax.Function.parameters +@349 := @342 (@343 (@344 @135) @127 @66) +@350 := @329 @305 +@351 := @350 @129 +@352 := @349 @351 +@353 := @315 @280 +@354 := @314 @353 +@355 := LexLeanPreservation.Rust.fnFallible +@356 := #11 +@359 := @354 (@355 @356 @307) +@360 := @329 @280 +@361 := @360 @129 +@362 := @359 @361 +@363 := LexLeanPreservation.RunConv +@364 := #13 +@368 := @363 @364 @333 @141 @129 +@370 := @283 @127 @288 +@371 := Exists.{1} +@372 := LexLeanPreservation.Rust.ROut +@373 := @371 @372 +@374 := And +@375 := LexLeanPreservation.Rust.RealizesFn +@379 := @374 (@375 @307 @141 @17) +@380 := LexLeanPreservation.Rust.RCI +@382 := @380 #15 +@383 := LexLeanPreservation.Rust.fnIdent +@384 := @383 @364 +@391 := (hne : @370) -> @373 (fun (ro : @372) => @379 (@382 @384 @356 @17)) +@406 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @313) -> + (hfn : @332) -> (hwt : @340) -> (hbind : @352) -> (hF : @362) -> (hA : @368) -> @391 +@408 := LexLeanPreservation.Rust.compose @0 +@409 := @306 @0 +@414 := (n : @3) -> @409 @141 @135 @17 @127 +@415 := @324 @73 +@418 := @317 (@415 @127) @331 +@422 := @107 @307 @141 @129 @339 +@423 := @363 @0 +@426 := @423 @333 @141 @129 +@440 := {c : @9} -> + {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @414) -> + (hfn : @418) -> (hwt : @422) -> (hbind : @352) -> (hF : @362) -> (hA : @426) -> @391 +@441 := @408 @1 +@442 := @409 @1 +@446 := (n : @3) -> @442 @135 @17 @127 +@449 := @115 @141 @129 @339 +@450 := @355 @1 +@453 := @354 (@450 @307) @361 +@454 := @380 @1 +@464 := (hbind : @352) -> + (hF : @453) -> (hA : @426) -> (hne : @370) -> @373 (fun (ro : @372) => @379 (@454 @384 @356 @17)) +@474 := {A : @10} -> + {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> {F : @280} -> {o : @282} -> (hB : @446) -> (hfn : @418) -> (hwt : @449) -> @464 +@475 := @441 @2 +@477 := @442 @2 @17 +@479 := (n : @3) -> @477 @127 +@480 := @121 @129 +@481 := @480 @339 +@490 := {f : @3} -> + {fn : @71} -> + {args : @125} -> + {env : @305} -> {F : @280} -> {o : @282} -> (hB : @479) -> (hfn : @418) -> (hwt : @481) -> @464 +@491 := @475 @60 +@493 := (n : @3) -> @477 @60 +@494 := @415 @60 +@495 := @317 @494 +@496 := @495 @331 +@497 := @450 @60 +@498 := @354 @497 +@499 := @498 @361 +@500 := @423 @60 +@502 := @500 @141 @129 +@504 := @454 (@383 @60) +@512 := (hF : @499) -> (hA : @502) -> (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 @356 @17)) +@521 := {fn : @71} -> + {args : @125} -> + {env : @305} -> + {F : @280} -> {o : @282} -> (hB : @493) -> (hfn : @496) -> (hwt : @481) -> (hbind : @352) -> @512 +@522 := @491 @91 +@524 := @495 (@330 @91) +@525 := @338 @91 +@526 := @480 @525 +@528 := @343 (@344 @91) +@540 := {args : @125} -> + {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @493) -> (hfn : @524) -> (hwt : @526) -> (hbind : @342 (@528 @127 @66) @351) -> @512 +@541 := @522 @56 +@542 := @218 @53 +@544 := @121 @542 @525 +@547 := @54 (@5 @135) @53 +@551 := @342 (@528 @547 @66) @351 +@554 := @54 (@5 @307) @53 +@575 := {env : @305} -> + {F : @280} -> + {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @544) -> + (hbind : @551) -> + (hF : @499) -> + (hA : @500 @554 @129) -> + (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 (@54 (@5 #12) @53) @17)) +@576 := @541 @69 +@577 := @232 @53 +@579 := @121 @577 @525 +@587 := @342 (@528 @542 @66) (@350 (@67 (@64 @217) @66)) +@590 := @54 (@5 @141) @53 +@609 := {F : @280} -> + {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @579) -> + (hbind : @587) -> + (hF : @499) -> + (hA : @500 @590 @129) -> + (hne : @370) -> @373 (fun (ro : @372) => @379 (@504 (@54 (@5 @356) @53) @17)) +@610 := @576 @70 +@611 := @249 @525 +@619 := @342 (@528 @577 @66) (@350 (@67 (@64 @231) @66)) +@621 := @498 (@360 @70) +@623 := @500 @547 @129 +@624 := @375 @70 +@643 := {o : @282} -> + (hB : @493) -> + (hfn : @524) -> + (hwt : @611) -> + (hbind : @619) -> + (hF : @621) -> + (hA : @623) -> + (hne : @370) -> @373 (fun (ro : @372) => @374 (@624 @141 @17) (@504 (@54 (@5 @333) @53) @17)) +@644 := @610 @272 +@645 := @257 @525 +@653 := @342 (@528 @248 @66) (@350 (@67 (@64 @214) @66)) +@654 := @500 @542 +@655 := @271 @127 +@656 := @654 @655 +@657 := @271 @135 +@675 := (hB : @493) -> + (hfn : @524) -> + (hwt : @645) -> + (hbind : @653) -> + (hF : @621) -> + (hA : @656) -> + (hne : @283 @657 @288) -> @373 (fun (ro : @372) => @374 (@624 (@271 @307) @17) (@504 @554 @17)) +@676 := @644 @95 +@677 := @265 @525 +@685 := @342 (@528 @256 @66) (@350 (@67 (@64 @228) @66)) +@686 := @500 @577 +@687 := @271 @129 +@705 := (hfn : @524) -> + (hwt : @677) -> + (hbind : @685) -> + (hF : @621) -> + (hA : @686 @687) -> + (hne : @283 @655 @288) -> @373 (fun (ro : @372) => @374 (@624 (@271 @141) @17) (@504 @590 @17)) +@706 := Eq.refl.{1} +@709 := @676 (@706 @316 @494) +@710 := @269 @525 +@718 := @342 (@528 @264 @66) (@350 (@67 (@64 @243) @66)) +@719 := @500 @248 +@720 := @271 @131 +@736 := (hwt : @710) -> + (hbind : @718) -> + (hF : @621) -> + (hA : @719 @720) -> + (hne : @283 @687 @288) -> @373 (fun (ro : @372) => @374 (@624 @657 @17) (@504 @547 @17)) +@737 := @709 @268 +@739 := @528 @56 @66 +@742 := @342 @739 (@350 @69) +@743 := @500 @256 +@744 := @271 @12 +@759 := (hbind : @742) -> + (hF : @621) -> + (hA : @743 @744) -> + (hne : @283 @720 @288) -> @373 (fun (ro : @372) => @374 (@624 @655 @17) (@504 @542 @17)) +@762 := @737 (@706 @341 @739) +@763 := @500 @264 +@764 := @271 @14 +@778 := (hF : @621) -> + (hA : @763 @764) -> + (hne : @283 @744 @288) -> @373 (fun (ro : @372) => @374 (@624 @687 @17) (@504 @577 @17)) +@781 := @762 (@706 @353 @497) +@795 := (hA : @500 @56 @272) -> + (hne : @283 @764 @288) -> @373 (fun (ro : @372) => @374 (@624 @720 @17) (@504 @248 @17)) +@796 := @781 @279 +@807 := (hne : @283 @272 @288) -> @373 (fun (ro : @372) => @374 (@624 @744 @17) (@504 @256 @17)) +@808 := @796 @300 +@814 := @374 (@624 @764 @17) (@504 @264 @17) +@816 := @373 (fun (ro : @372) => @814) +@818 := @373 (fun (__e_ro : @372) => @814) +@822 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@823 := (__e_hrep : @822) -> @818 +@824 := fun (__e_hrep : @822) => @808 +@825 := (number : @3) -> @823 +@826 := fun (number : @3) => @824 +\end{coremodule} +\end{lexlean} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R4/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R4/Compose/RustStd.lean deleted file mode 100644 index f356e0710..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R4/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4 -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (values : (List Nat)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) values)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.denote values) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) values)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat) values) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.root values) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R4/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R4/Compose/RustStd.lex.tex new file mode 100644 index 000000000..64059f4f3 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R4/Compose/RustStd.lex.tex @@ -0,0 +1,461 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4, + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd.root : @923 := @924 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd.program +@1 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd.krate +@2 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd.flags +@3 := Nat +@4 := List.{0} +@5 := @4 @3 +@6 := #1 +@7 := LexLeanTarget.TargetSyntax.Value.nat +@8 := LexLeanPreservation.encList +@9 := @8 @3 +@10 := @9 @7 +@11 := @10 @6 +@12 := LexLeanTarget.TargetSyntax.Ty.nat +@13 := LexLeanTarget.TargetSyntax.Ty.list +@14 := @13 @12 +@15 := #0 +@16 := LexLeanTarget.TargetSyntax.Program +@17 := LexLeanPreservation.Rust.RCrate +@18 := LexLeanPreservation.Rust.Flags +@19 := LexLeanPreservation.Rust.WT +@20 := #3 +@21 := @19 @20 +@22 := #2 +@24 := @21 @22 @6 +@25 := @7 @15 +@31 := {p : @16} -> {c : @17} -> {A : @18} -> (n : @3) -> @24 @25 @12 +@33 := LexLeanPreservation.Rust.wt_nat @0 +@34 := @19 @0 +@41 := {c : @17} -> {A : @18} -> (n : @3) -> @34 @22 @6 @25 @12 +@42 := @33 @1 +@43 := @34 @1 +@48 := {A : @18} -> (n : @3) -> @43 @6 @25 @12 +@49 := @42 @2 +@50 := @43 @2 +@51 := @50 @25 +@52 := @51 @12 +@53 := (n : @3) -> @52 +@55 := fun (__x : @3) => @49 @15 +@56 := Sort 1 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := (a._@._internal._hyg.#0 : @15) -> @57 +@59 := LexLeanTarget.TargetSyntax.Ty +@60 := #6 +@61 := @19 @60 +@62 := #5 +@63 := @61 @62 +@64 := #4 +@65 := @63 @64 +@66 := @22 @15 +@69 := (x : @22) -> @65 @66 @6 +@70 := @4 @20 +@71 := #7 +@74 := @19 @71 @60 @62 +@77 := @8 @64 @20 @15 +@78 := @74 @77 +@79 := @13 @22 +@88 := {p : @16} -> + {c : @17} -> + {A : @18} -> {α : @56} -> {e : @58} -> {t : @59} -> (h : @69) -> (xs : @70) -> @78 @79 +@90 := LexLeanPreservation.Rust.wt_encList @0 +@92 := @34 @62 @64 +@106 := {c : @17} -> + {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @22) -> @92 @66 @6) -> (xs : @70) -> @34 @60 @62 @77 @79 +@107 := @90 @1 +@108 := @43 @64 +@120 := {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @22) -> @108 @66 @6) -> (xs : @70) -> @43 @62 @77 @79 +@121 := @107 @2 +@123 := @50 @66 @6 +@131 := {α : @56} -> {e : @58} -> {t : @59} -> (h : (x : @22) -> @123) -> (xs : @70) -> @50 @77 @79 +@132 := @121 @3 +@142 := {e : (a._@._internal._hyg.#0 : @3) -> @57} -> + {t : @59} -> (h : (x : @3) -> @123) -> (xs : @5) -> @50 (@9 @20 @15) @79 +@143 := @132 @7 +@145 := (x : @3) -> @51 @6 +@146 := @10 @15 +@147 := @50 @146 +@151 := {t : @59} -> (h : @145) -> (xs : @5) -> @147 @79 +@152 := @143 @12 +@156 := (h : (x : @3) -> @52) -> (xs : @5) -> @147 @14 +@158 := @152 @55 @6 +@160 := @50 @11 @14 +@161 := List.nil.{0} +@162 := List.cons.{0} +@163 := @161 @57 +@164 := @162 @57 +@166 := @164 @11 @163 +@169 := Prod.{0, 0} @3 @57 +@170 := 0 +@174 := Prod.mk.{0, 0} @3 @57 @170 +@175 := @174 @11 +@176 := @161 @169 +@177 := @162 @169 +@179 := @177 @175 @176 +@180 := Bool.true +@181 := LexLeanTarget.TargetSyntax.Function +@182 := LexLeanTarget.TargetSyntax.Program.functions +@183 := @182 @0 +@184 := @161 @3 +@185 := @161 @59 +@186 := LexLeanTarget.TargetSyntax.Ty.unit +@187 := LexLeanTarget.TargetSyntax.Value.unit +@190 := LexLeanTarget.TargetSyntax.Expr.value @186 @187 +@195 := LexLeanTarget.TargetSyntax.Function.mk @184 @185 @186 @190 +@200 := List.getD.{0} @181 @183 @170 @195 +@204 := fun (__e_n : @3) => + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd.root @15 @170 +@205 := LexLeanPreservation.Rust.WTL +@213 := {p : @16} -> {c : @17} -> {A : @18} -> @205 @22 @6 @15 @163 @185 +@215 := LexLeanPreservation.Rust.wtl_nil @0 +@216 := @205 @0 +@222 := {c : @17} -> {A : @18} -> @216 @6 @15 @163 @185 +@223 := @215 @1 +@224 := @216 @1 +@228 := {A : @18} -> @224 @15 @163 @185 +@229 := @223 @2 +@230 := @224 @2 +@231 := @230 @163 +@232 := @231 @185 +@233 := @4 @57 +@234 := @4 @59 +@236 := @65 @20 @22 +@241 := @205 @71 @60 @62 @22 @6 +@242 := #8 +@245 := @205 @242 @71 @60 +@247 := @164 @62 @20 +@248 := @245 @247 +@249 := @162 @59 +@251 := @249 @64 @22 +@261 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {v : @57} -> {t : @59} -> {vs : @233} -> {ts : @234} -> (h : @236) -> (hs : @241) -> @248 @251 +@263 := LexLeanPreservation.Rust.wtl_cons @0 +@281 := {c : @17} -> + {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @233} -> + {ts : @234} -> (h : @92 @20 @22) -> (hs : @216 @60 @62 @22 @6) -> @216 @71 @60 @247 @251 +@282 := @263 @1 +@297 := {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @233} -> {ts : @234} -> (h : @108 @20 @22) -> (hs : @224 @62 @22 @6) -> @224 @60 @247 @251 +@298 := @282 @2 +@300 := @50 @20 @22 +@302 := @230 @22 @6 +@310 := {v : @57} -> + {t : @59} -> {vs : @233} -> {ts : @234} -> (h : @300) -> (hs : @302) -> @230 @247 @251 +@311 := @298 @11 +@312 := @10 @64 +@314 := @50 @312 @22 +@315 := @10 @60 +@316 := @164 @315 +@324 := {t : @59} -> {vs : @233} -> {ts : @234} -> (h : @314) -> (hs : @302) -> @230 (@316 @20) @251 +@325 := @311 @14 +@326 := @10 @20 +@328 := @50 @326 @14 +@329 := @10 @62 +@330 := @164 @329 +@332 := @230 (@330 @20) +@333 := @249 @14 +@334 := @333 @22 +@339 := {vs : @233} -> {ts : @234} -> (h : @328) -> (hs : @302) -> @332 @334 +@340 := @325 @163 +@341 := @10 @22 +@343 := @50 @341 @14 +@344 := @231 @6 +@346 := @164 @312 @163 +@347 := @230 @346 +@351 := {ts : @234} -> (h : @343) -> (hs : @344) -> @347 @334 +@352 := @340 @185 +@354 := @164 @326 @163 +@355 := @230 @354 +@356 := @333 @185 +@359 := (h : @160) -> (hs : @232) -> @355 @356 +@360 := @352 @158 +@362 := @164 @341 @163 +@363 := @230 @362 +@365 := (hs : @232) -> @363 @356 +@366 := @360 @229 +@367 := @230 @166 +@368 := @367 @356 +@369 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.denote +@370 := @369 @6 +@371 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.__fits_0 +@372 := @371 @6 +@375 := @7 (Production.Main.sumAll @6) +@377 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.root @6 +@378 := Bool +@379 := Ne.{1} +@380 := LexLeanPreservation.Obs +@381 := @379 @380 +@382 := LexLeanPreservation.Rel +@385 := @381 (@382 @6 @15) +@386 := LexLeanPreservation.Obs.stuck +@389 := (f : @378) -> (v : @57) -> @385 @386 +@391 := LexLeanPreservation.Rust.rel_ne_stuck @372 +@397 := (v : @57) -> @381 (@382 (@371 @22) @15) @386 +@398 := @391 @375 +@402 := @381 (@382 @372 @375) @386 +@403 := @4 @169 +@404 := LexLeanPreservation.Rust.FunSem +@405 := #9 +@411 := (n : @3) -> @404 @405 @242 @71 @15 @60 +@412 := Eq.{1} +@413 := Option.{0} +@414 := @413 @181 +@415 := @412 @414 +@422 := LexLeanRuntime.index (@4 @181) @181 (LexLeanRuntime.instIndexableList @181) +@426 := @415 (@422 (@182 @405) @60) +@427 := Option.some.{0} +@428 := @427 @181 +@429 := @428 @62 +@430 := @426 @429 +@431 := #10 +@435 := @205 @431 @405 @242 @62 +@436 := LexLeanTarget.TargetSyntax.Function.types +@437 := @436 @60 +@438 := @435 @437 +@439 := @413 @403 +@440 := @412 @439 +@441 := LexLeanTarget.TargetSemantics.bindAll +@442 := LexLeanTarget.TargetSyntax.Function.parameters +@447 := @440 (@441 (@442 @71) @60 @176) +@448 := @427 @403 +@449 := @448 @62 +@450 := @447 @449 +@451 := @413 @378 +@452 := @412 @451 +@453 := LexLeanPreservation.Rust.fnFallible +@454 := #11 +@457 := @452 (@453 @454 @405) +@458 := @427 @378 +@459 := @458 @62 +@460 := @457 @459 +@461 := LexLeanPreservation.RunConv +@462 := #13 +@466 := @461 @462 @431 @242 @62 +@468 := @381 @60 @386 +@469 := Exists.{1} +@470 := LexLeanPreservation.Rust.ROut +@471 := @469 @470 +@472 := And +@473 := LexLeanPreservation.Rust.RealizesFn +@477 := @472 (@473 @405 @242 @15) +@478 := LexLeanPreservation.Rust.RCI +@480 := @478 #15 +@481 := LexLeanPreservation.Rust.fnIdent +@482 := @481 @462 +@489 := (hne : @468) -> @471 (fun (ro : @470) => @477 (@480 @482 @454 @15)) +@504 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @403} -> + {F : @378} -> + {o : @380} -> + (hB : @411) -> + (hfn : @430) -> (hwt : @438) -> (hbind : @450) -> (hF : @460) -> (hA : @466) -> @489 +@506 := LexLeanPreservation.Rust.compose @0 +@507 := @404 @0 +@512 := (n : @3) -> @507 @242 @71 @15 @60 +@513 := @422 @183 +@516 := @415 (@513 @60) @429 +@520 := @216 @405 @242 @62 @437 +@521 := @461 @0 +@524 := @521 @431 @242 @62 +@538 := {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @403} -> + {F : @378} -> + {o : @380} -> + (hB : @512) -> + (hfn : @516) -> (hwt : @520) -> (hbind : @450) -> (hF : @460) -> (hA : @524) -> @489 +@539 := @506 @1 +@540 := @507 @1 +@544 := (n : @3) -> @540 @71 @15 @60 +@547 := @224 @242 @62 @437 +@548 := @453 @1 +@551 := @452 (@548 @405) @459 +@552 := @478 @1 +@562 := (hbind : @450) -> + (hF : @551) -> (hA : @524) -> (hne : @468) -> @471 (fun (ro : @470) => @477 (@552 @482 @454 @15)) +@572 := {A : @18} -> + {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @403} -> {F : @378} -> {o : @380} -> (hB : @544) -> (hfn : @516) -> (hwt : @547) -> @562 +@573 := @539 @2 +@575 := @540 @2 @15 +@577 := (n : @3) -> @575 @60 +@578 := @230 @62 +@579 := @578 @437 +@588 := {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @403} -> {F : @378} -> {o : @380} -> (hB : @577) -> (hfn : @516) -> (hwt : @579) -> @562 +@589 := @573 @170 +@591 := (n : @3) -> @575 @170 +@592 := @513 @170 +@593 := @415 @592 +@594 := @593 @429 +@595 := @548 @170 +@596 := @452 @595 +@597 := @596 @459 +@598 := @521 @170 +@600 := @598 @242 @62 +@602 := @552 (@481 @170) +@610 := (hF : @597) -> (hA : @600) -> (hne : @468) -> @471 (fun (ro : @470) => @477 (@602 @454 @15)) +@619 := {fn : @181} -> + {args : @233} -> + {env : @403} -> + {F : @378} -> {o : @380} -> (hB : @591) -> (hfn : @594) -> (hwt : @579) -> (hbind : @450) -> @610 +@620 := @589 @200 +@622 := @593 (@428 @200) +@623 := @436 @200 +@624 := @578 @623 +@626 := @441 (@442 @200) +@638 := {args : @233} -> + {env : @403} -> + {F : @378} -> + {o : @380} -> + (hB : @591) -> (hfn : @622) -> (hwt : @624) -> (hbind : @440 (@626 @60 @176) @449) -> @610 +@639 := @620 @166 +@640 := @316 @163 +@642 := @230 @640 @623 +@645 := @164 (@10 @71) @163 +@649 := @440 (@626 @645 @176) @449 +@652 := @164 (@10 @405) @163 +@673 := {env : @403} -> + {F : @378} -> + {o : @380} -> + (hB : @591) -> + (hfn : @622) -> + (hwt : @642) -> + (hbind : @649) -> + (hF : @597) -> + (hA : @598 @652 @62) -> + (hne : @468) -> @471 (fun (ro : @470) => @477 (@602 (@164 (@10 #12) @163) @15)) +@674 := @639 @179 +@675 := @330 @163 +@677 := @230 @675 @623 +@685 := @440 (@626 @640 @176) (@448 (@177 (@174 @315) @176)) +@688 := @164 (@10 @242) @163 +@707 := {F : @378} -> + {o : @380} -> + (hB : @591) -> + (hfn : @622) -> + (hwt : @677) -> + (hbind : @685) -> + (hF : @597) -> + (hA : @598 @688 @62) -> + (hne : @468) -> @471 (fun (ro : @470) => @477 (@602 (@164 (@10 @454) @163) @15)) +@708 := @674 @180 +@709 := @347 @623 +@717 := @440 (@626 @675 @176) (@448 (@177 (@174 @329) @176)) +@719 := @596 (@458 @180) +@721 := @598 @645 @62 +@722 := @473 @180 +@741 := {o : @380} -> + (hB : @591) -> + (hfn : @622) -> + (hwt : @709) -> + (hbind : @717) -> + (hF : @719) -> + (hA : @721) -> + (hne : @468) -> @471 (fun (ro : @470) => @472 (@722 @242 @15) (@602 (@164 (@10 @431) @163) @15)) +@742 := @708 @370 +@743 := @355 @623 +@751 := @440 (@626 @346 @176) (@448 (@177 (@174 @312) @176)) +@752 := @598 @640 +@753 := @369 @60 +@754 := @752 @753 +@755 := @369 @71 +@773 := (hB : @591) -> + (hfn : @622) -> + (hwt : @743) -> + (hbind : @751) -> + (hF : @719) -> + (hA : @754) -> + (hne : @381 @755 @386) -> @471 (fun (ro : @470) => @472 (@722 (@369 @405) @15) (@602 @652 @15)) +@774 := @742 @204 +@775 := @363 @623 +@783 := @440 (@626 @354 @176) (@448 (@177 (@174 @326) @176)) +@784 := @598 @675 +@785 := @369 @62 +@803 := (hfn : @622) -> + (hwt : @775) -> + (hbind : @783) -> + (hF : @719) -> + (hA : @784 @785) -> + (hne : @381 @753 @386) -> @471 (fun (ro : @470) => @472 (@722 (@369 @242) @15) (@602 @688 @15)) +@804 := Eq.refl.{1} +@807 := @774 (@804 @414 @592) +@808 := @367 @623 +@816 := @440 (@626 @362 @176) (@448 (@177 (@174 @341) @176)) +@817 := @598 @346 +@818 := @369 @64 +@834 := (hwt : @808) -> + (hbind : @816) -> + (hF : @719) -> + (hA : @817 @818) -> + (hne : @381 @785 @386) -> @471 (fun (ro : @470) => @472 (@722 @755 @15) (@602 @645 @15)) +@835 := @807 @366 +@837 := @626 @166 @176 +@840 := @440 @837 (@448 @179) +@841 := @598 @354 +@842 := @369 @20 +@857 := (hbind : @840) -> + (hF : @719) -> + (hA : @841 @842) -> + (hne : @381 @818 @386) -> @471 (fun (ro : @470) => @472 (@722 @753 @15) (@602 @640 @15)) +@860 := @835 (@804 @439 @837) +@861 := @598 @362 +@862 := @369 @22 +@876 := (hF : @719) -> + (hA : @861 @862) -> + (hne : @381 @842 @386) -> @471 (fun (ro : @470) => @472 (@722 @785 @15) (@602 @675 @15)) +@879 := @860 (@804 @451 @595) +@893 := (hA : @598 @166 @370) -> + (hne : @381 @862 @386) -> @471 (fun (ro : @470) => @472 (@722 @818 @15) (@602 @346 @15)) +@894 := @879 @377 +@905 := (hne : @381 @370 @386) -> @471 (fun (ro : @470) => @472 (@722 @842 @15) (@602 @354 @15)) +@906 := @894 @398 +@912 := @472 (@722 @862 @15) (@602 @362 @15) +@914 := @471 (fun (ro : @470) => @912) +@916 := @471 (fun (__e_ro : @470) => @912) +@920 := LexLeanPreservation.Rust.RepresentableL (@164 @146 @163) +@921 := (__e_hrep : @920) -> @916 +@922 := fun (__e_hrep : @920) => @906 +@923 := (values : @5) -> @921 +@924 := fun (values : @5) => @922 +\end{coremodule} +\end{lexlean} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R5/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R5/Compose/RustStd.lean deleted file mode 100644 index 61d4cb290..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R5/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5 -import LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (values : (List Nat)) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) values)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.denote values) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.nat) values)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList _root_.LexLeanPreservation.Rust.wt_nat) values) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.root values) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R5/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R5/Compose/RustStd.lex.tex new file mode 100644 index 000000000..00562b841 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R5/Compose/RustStd.lex.tex @@ -0,0 +1,461 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5, + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd.root : @923 := @924 { + all: [LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd.program +@1 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd.krate +@2 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd.flags +@3 := Nat +@4 := List.{0} +@5 := @4 @3 +@6 := #1 +@7 := LexLeanTarget.TargetSyntax.Value.nat +@8 := LexLeanPreservation.encList +@9 := @8 @3 +@10 := @9 @7 +@11 := @10 @6 +@12 := LexLeanTarget.TargetSyntax.Ty.nat +@13 := LexLeanTarget.TargetSyntax.Ty.list +@14 := @13 @12 +@15 := #0 +@16 := LexLeanTarget.TargetSyntax.Program +@17 := LexLeanPreservation.Rust.RCrate +@18 := LexLeanPreservation.Rust.Flags +@19 := LexLeanPreservation.Rust.WT +@20 := #3 +@21 := @19 @20 +@22 := #2 +@24 := @21 @22 @6 +@25 := @7 @15 +@31 := {p : @16} -> {c : @17} -> {A : @18} -> (n : @3) -> @24 @25 @12 +@33 := LexLeanPreservation.Rust.wt_nat @0 +@34 := @19 @0 +@41 := {c : @17} -> {A : @18} -> (n : @3) -> @34 @22 @6 @25 @12 +@42 := @33 @1 +@43 := @34 @1 +@48 := {A : @18} -> (n : @3) -> @43 @6 @25 @12 +@49 := @42 @2 +@50 := @43 @2 +@51 := @50 @25 +@52 := @51 @12 +@53 := (n : @3) -> @52 +@55 := fun (__x : @3) => @49 @15 +@56 := Sort 1 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := (a._@._internal._hyg.#0 : @15) -> @57 +@59 := LexLeanTarget.TargetSyntax.Ty +@60 := #6 +@61 := @19 @60 +@62 := #5 +@63 := @61 @62 +@64 := #4 +@65 := @63 @64 +@66 := @22 @15 +@69 := (x : @22) -> @65 @66 @6 +@70 := @4 @20 +@71 := #7 +@74 := @19 @71 @60 @62 +@77 := @8 @64 @20 @15 +@78 := @74 @77 +@79 := @13 @22 +@88 := {p : @16} -> + {c : @17} -> + {A : @18} -> {α : @56} -> {e : @58} -> {t : @59} -> (h : @69) -> (xs : @70) -> @78 @79 +@90 := LexLeanPreservation.Rust.wt_encList @0 +@92 := @34 @62 @64 +@106 := {c : @17} -> + {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @22) -> @92 @66 @6) -> (xs : @70) -> @34 @60 @62 @77 @79 +@107 := @90 @1 +@108 := @43 @64 +@120 := {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @22) -> @108 @66 @6) -> (xs : @70) -> @43 @62 @77 @79 +@121 := @107 @2 +@123 := @50 @66 @6 +@131 := {α : @56} -> {e : @58} -> {t : @59} -> (h : (x : @22) -> @123) -> (xs : @70) -> @50 @77 @79 +@132 := @121 @3 +@142 := {e : (a._@._internal._hyg.#0 : @3) -> @57} -> + {t : @59} -> (h : (x : @3) -> @123) -> (xs : @5) -> @50 (@9 @20 @15) @79 +@143 := @132 @7 +@145 := (x : @3) -> @51 @6 +@146 := @10 @15 +@147 := @50 @146 +@151 := {t : @59} -> (h : @145) -> (xs : @5) -> @147 @79 +@152 := @143 @12 +@156 := (h : (x : @3) -> @52) -> (xs : @5) -> @147 @14 +@158 := @152 @55 @6 +@160 := @50 @11 @14 +@161 := List.nil.{0} +@162 := List.cons.{0} +@163 := @161 @57 +@164 := @162 @57 +@166 := @164 @11 @163 +@169 := Prod.{0, 0} @3 @57 +@170 := 0 +@174 := Prod.mk.{0, 0} @3 @57 @170 +@175 := @174 @11 +@176 := @161 @169 +@177 := @162 @169 +@179 := @177 @175 @176 +@180 := Bool.false +@181 := LexLeanTarget.TargetSyntax.Function +@182 := LexLeanTarget.TargetSyntax.Program.functions +@183 := @182 @0 +@184 := @161 @3 +@185 := @161 @59 +@186 := LexLeanTarget.TargetSyntax.Ty.unit +@187 := LexLeanTarget.TargetSyntax.Value.unit +@190 := LexLeanTarget.TargetSyntax.Expr.value @186 @187 +@195 := LexLeanTarget.TargetSyntax.Function.mk @184 @185 @186 @190 +@200 := List.getD.{0} @181 @183 @170 @195 +@204 := fun (__e_n : @3) => + LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd.root @15 @170 +@205 := LexLeanPreservation.Rust.WTL +@213 := {p : @16} -> {c : @17} -> {A : @18} -> @205 @22 @6 @15 @163 @185 +@215 := LexLeanPreservation.Rust.wtl_nil @0 +@216 := @205 @0 +@222 := {c : @17} -> {A : @18} -> @216 @6 @15 @163 @185 +@223 := @215 @1 +@224 := @216 @1 +@228 := {A : @18} -> @224 @15 @163 @185 +@229 := @223 @2 +@230 := @224 @2 +@231 := @230 @163 +@232 := @231 @185 +@233 := @4 @57 +@234 := @4 @59 +@236 := @65 @20 @22 +@241 := @205 @71 @60 @62 @22 @6 +@242 := #8 +@245 := @205 @242 @71 @60 +@247 := @164 @62 @20 +@248 := @245 @247 +@249 := @162 @59 +@251 := @249 @64 @22 +@261 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {v : @57} -> {t : @59} -> {vs : @233} -> {ts : @234} -> (h : @236) -> (hs : @241) -> @248 @251 +@263 := LexLeanPreservation.Rust.wtl_cons @0 +@281 := {c : @17} -> + {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @233} -> + {ts : @234} -> (h : @92 @20 @22) -> (hs : @216 @60 @62 @22 @6) -> @216 @71 @60 @247 @251 +@282 := @263 @1 +@297 := {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @233} -> {ts : @234} -> (h : @108 @20 @22) -> (hs : @224 @62 @22 @6) -> @224 @60 @247 @251 +@298 := @282 @2 +@300 := @50 @20 @22 +@302 := @230 @22 @6 +@310 := {v : @57} -> + {t : @59} -> {vs : @233} -> {ts : @234} -> (h : @300) -> (hs : @302) -> @230 @247 @251 +@311 := @298 @11 +@312 := @10 @64 +@314 := @50 @312 @22 +@315 := @10 @60 +@316 := @164 @315 +@324 := {t : @59} -> {vs : @233} -> {ts : @234} -> (h : @314) -> (hs : @302) -> @230 (@316 @20) @251 +@325 := @311 @14 +@326 := @10 @20 +@328 := @50 @326 @14 +@329 := @10 @62 +@330 := @164 @329 +@332 := @230 (@330 @20) +@333 := @249 @14 +@334 := @333 @22 +@339 := {vs : @233} -> {ts : @234} -> (h : @328) -> (hs : @302) -> @332 @334 +@340 := @325 @163 +@341 := @10 @22 +@343 := @50 @341 @14 +@344 := @231 @6 +@346 := @164 @312 @163 +@347 := @230 @346 +@351 := {ts : @234} -> (h : @343) -> (hs : @344) -> @347 @334 +@352 := @340 @185 +@354 := @164 @326 @163 +@355 := @230 @354 +@356 := @333 @185 +@359 := (h : @160) -> (hs : @232) -> @355 @356 +@360 := @352 @158 +@362 := @164 @341 @163 +@363 := @230 @362 +@365 := (hs : @232) -> @363 @356 +@366 := @360 @229 +@367 := @230 @166 +@368 := @367 @356 +@369 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.denote +@370 := @369 @6 +@371 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.__fits_0 +@372 := @371 @6 +@375 := @7 (Production.Main.headOr @6) +@377 := LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.root @6 +@378 := Bool +@379 := Ne.{1} +@380 := LexLeanPreservation.Obs +@381 := @379 @380 +@382 := LexLeanPreservation.Rel +@385 := @381 (@382 @6 @15) +@386 := LexLeanPreservation.Obs.stuck +@389 := (f : @378) -> (v : @57) -> @385 @386 +@391 := LexLeanPreservation.Rust.rel_ne_stuck @372 +@397 := (v : @57) -> @381 (@382 (@371 @22) @15) @386 +@398 := @391 @375 +@402 := @381 (@382 @372 @375) @386 +@403 := @4 @169 +@404 := LexLeanPreservation.Rust.FunSem +@405 := #9 +@411 := (n : @3) -> @404 @405 @242 @71 @15 @60 +@412 := Eq.{1} +@413 := Option.{0} +@414 := @413 @181 +@415 := @412 @414 +@422 := LexLeanRuntime.index (@4 @181) @181 (LexLeanRuntime.instIndexableList @181) +@426 := @415 (@422 (@182 @405) @60) +@427 := Option.some.{0} +@428 := @427 @181 +@429 := @428 @62 +@430 := @426 @429 +@431 := #10 +@435 := @205 @431 @405 @242 @62 +@436 := LexLeanTarget.TargetSyntax.Function.types +@437 := @436 @60 +@438 := @435 @437 +@439 := @413 @403 +@440 := @412 @439 +@441 := LexLeanTarget.TargetSemantics.bindAll +@442 := LexLeanTarget.TargetSyntax.Function.parameters +@447 := @440 (@441 (@442 @71) @60 @176) +@448 := @427 @403 +@449 := @448 @62 +@450 := @447 @449 +@451 := @413 @378 +@452 := @412 @451 +@453 := LexLeanPreservation.Rust.fnFallible +@454 := #11 +@457 := @452 (@453 @454 @405) +@458 := @427 @378 +@459 := @458 @62 +@460 := @457 @459 +@461 := LexLeanPreservation.RunConv +@462 := #13 +@466 := @461 @462 @431 @242 @62 +@468 := @381 @60 @386 +@469 := Exists.{1} +@470 := LexLeanPreservation.Rust.ROut +@471 := @469 @470 +@472 := And +@473 := LexLeanPreservation.Rust.RealizesFn +@477 := @472 (@473 @405 @242 @15) +@478 := LexLeanPreservation.Rust.RCI +@480 := @478 #15 +@481 := LexLeanPreservation.Rust.fnIdent +@482 := @481 @462 +@489 := (hne : @468) -> @471 (fun (ro : @470) => @477 (@480 @482 @454 @15)) +@504 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @403} -> + {F : @378} -> + {o : @380} -> + (hB : @411) -> + (hfn : @430) -> (hwt : @438) -> (hbind : @450) -> (hF : @460) -> (hA : @466) -> @489 +@506 := LexLeanPreservation.Rust.compose @0 +@507 := @404 @0 +@512 := (n : @3) -> @507 @242 @71 @15 @60 +@513 := @422 @183 +@516 := @415 (@513 @60) @429 +@520 := @216 @405 @242 @62 @437 +@521 := @461 @0 +@524 := @521 @431 @242 @62 +@538 := {c : @17} -> + {A : @18} -> + {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @403} -> + {F : @378} -> + {o : @380} -> + (hB : @512) -> + (hfn : @516) -> (hwt : @520) -> (hbind : @450) -> (hF : @460) -> (hA : @524) -> @489 +@539 := @506 @1 +@540 := @507 @1 +@544 := (n : @3) -> @540 @71 @15 @60 +@547 := @224 @242 @62 @437 +@548 := @453 @1 +@551 := @452 (@548 @405) @459 +@552 := @478 @1 +@562 := (hbind : @450) -> + (hF : @551) -> (hA : @524) -> (hne : @468) -> @471 (fun (ro : @470) => @477 (@552 @482 @454 @15)) +@572 := {A : @18} -> + {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @403} -> {F : @378} -> {o : @380} -> (hB : @544) -> (hfn : @516) -> (hwt : @547) -> @562 +@573 := @539 @2 +@575 := @540 @2 @15 +@577 := (n : @3) -> @575 @60 +@578 := @230 @62 +@579 := @578 @437 +@588 := {f : @3} -> + {fn : @181} -> + {args : @233} -> + {env : @403} -> {F : @378} -> {o : @380} -> (hB : @577) -> (hfn : @516) -> (hwt : @579) -> @562 +@589 := @573 @170 +@591 := (n : @3) -> @575 @170 +@592 := @513 @170 +@593 := @415 @592 +@594 := @593 @429 +@595 := @548 @170 +@596 := @452 @595 +@597 := @596 @459 +@598 := @521 @170 +@600 := @598 @242 @62 +@602 := @552 (@481 @170) +@610 := (hF : @597) -> (hA : @600) -> (hne : @468) -> @471 (fun (ro : @470) => @477 (@602 @454 @15)) +@619 := {fn : @181} -> + {args : @233} -> + {env : @403} -> + {F : @378} -> {o : @380} -> (hB : @591) -> (hfn : @594) -> (hwt : @579) -> (hbind : @450) -> @610 +@620 := @589 @200 +@622 := @593 (@428 @200) +@623 := @436 @200 +@624 := @578 @623 +@626 := @441 (@442 @200) +@638 := {args : @233} -> + {env : @403} -> + {F : @378} -> + {o : @380} -> + (hB : @591) -> (hfn : @622) -> (hwt : @624) -> (hbind : @440 (@626 @60 @176) @449) -> @610 +@639 := @620 @166 +@640 := @316 @163 +@642 := @230 @640 @623 +@645 := @164 (@10 @71) @163 +@649 := @440 (@626 @645 @176) @449 +@652 := @164 (@10 @405) @163 +@673 := {env : @403} -> + {F : @378} -> + {o : @380} -> + (hB : @591) -> + (hfn : @622) -> + (hwt : @642) -> + (hbind : @649) -> + (hF : @597) -> + (hA : @598 @652 @62) -> + (hne : @468) -> @471 (fun (ro : @470) => @477 (@602 (@164 (@10 #12) @163) @15)) +@674 := @639 @179 +@675 := @330 @163 +@677 := @230 @675 @623 +@685 := @440 (@626 @640 @176) (@448 (@177 (@174 @315) @176)) +@688 := @164 (@10 @242) @163 +@707 := {F : @378} -> + {o : @380} -> + (hB : @591) -> + (hfn : @622) -> + (hwt : @677) -> + (hbind : @685) -> + (hF : @597) -> + (hA : @598 @688 @62) -> + (hne : @468) -> @471 (fun (ro : @470) => @477 (@602 (@164 (@10 @454) @163) @15)) +@708 := @674 @180 +@709 := @347 @623 +@717 := @440 (@626 @675 @176) (@448 (@177 (@174 @329) @176)) +@719 := @596 (@458 @180) +@721 := @598 @645 @62 +@722 := @473 @180 +@741 := {o : @380} -> + (hB : @591) -> + (hfn : @622) -> + (hwt : @709) -> + (hbind : @717) -> + (hF : @719) -> + (hA : @721) -> + (hne : @468) -> @471 (fun (ro : @470) => @472 (@722 @242 @15) (@602 (@164 (@10 @431) @163) @15)) +@742 := @708 @370 +@743 := @355 @623 +@751 := @440 (@626 @346 @176) (@448 (@177 (@174 @312) @176)) +@752 := @598 @640 +@753 := @369 @60 +@754 := @752 @753 +@755 := @369 @71 +@773 := (hB : @591) -> + (hfn : @622) -> + (hwt : @743) -> + (hbind : @751) -> + (hF : @719) -> + (hA : @754) -> + (hne : @381 @755 @386) -> @471 (fun (ro : @470) => @472 (@722 (@369 @405) @15) (@602 @652 @15)) +@774 := @742 @204 +@775 := @363 @623 +@783 := @440 (@626 @354 @176) (@448 (@177 (@174 @326) @176)) +@784 := @598 @675 +@785 := @369 @62 +@803 := (hfn : @622) -> + (hwt : @775) -> + (hbind : @783) -> + (hF : @719) -> + (hA : @784 @785) -> + (hne : @381 @753 @386) -> @471 (fun (ro : @470) => @472 (@722 (@369 @242) @15) (@602 @688 @15)) +@804 := Eq.refl.{1} +@807 := @774 (@804 @414 @592) +@808 := @367 @623 +@816 := @440 (@626 @362 @176) (@448 (@177 (@174 @341) @176)) +@817 := @598 @346 +@818 := @369 @64 +@834 := (hwt : @808) -> + (hbind : @816) -> + (hF : @719) -> + (hA : @817 @818) -> + (hne : @381 @785 @386) -> @471 (fun (ro : @470) => @472 (@722 @755 @15) (@602 @645 @15)) +@835 := @807 @366 +@837 := @626 @166 @176 +@840 := @440 @837 (@448 @179) +@841 := @598 @354 +@842 := @369 @20 +@857 := (hbind : @840) -> + (hF : @719) -> + (hA : @841 @842) -> + (hne : @381 @818 @386) -> @471 (fun (ro : @470) => @472 (@722 @753 @15) (@602 @640 @15)) +@860 := @835 (@804 @439 @837) +@861 := @598 @362 +@862 := @369 @22 +@876 := (hF : @719) -> + (hA : @861 @862) -> + (hne : @381 @842 @386) -> @471 (fun (ro : @470) => @472 (@722 @785 @15) (@602 @675 @15)) +@879 := @860 (@804 @451 @595) +@893 := (hA : @598 @166 @370) -> + (hne : @381 @862 @386) -> @471 (fun (ro : @470) => @472 (@722 @818 @15) (@602 @346 @15)) +@894 := @879 @377 +@905 := (hne : @381 @370 @386) -> @471 (fun (ro : @470) => @472 (@722 @842 @15) (@602 @354 @15)) +@906 := @894 @398 +@912 := @472 (@722 @862 @15) (@602 @362 @15) +@914 := @471 (fun (ro : @470) => @912) +@916 := @471 (fun (__e_ro : @470) => @912) +@920 := LexLeanPreservation.Rust.RepresentableL (@164 @146 @163) +@921 := (__e_hrep : @920) -> @916 +@922 := fun (__e_hrep : @920) => @906 +@923 := (values : @5) -> @921 +@924 := fun (values : @5) => @922 +\end{coremodule} +\end{lexlean} diff --git a/examples/production/expected/verify/preserve/audit.txt b/examples/production/expected/verify/preserve/audit.txt index 2d113a0c6..5759e90b4 100644 --- a/examples/production/expected/verify/preserve/audit.txt +++ b/examples/production/expected/verify/preserve/audit.txt @@ -7803,6 +7803,8 @@ 'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] -- statement vocabulary inductive LexLeanPreservation.Obs : Type number of parameters: 0 diff --git a/examples/production/expected/verify/preserve/preservation.json b/examples/production/expected/verify/preserve/preservation.json index 4ebbaeab5..15f5e7599 100644 --- a/examples/production/expected/verify/preserve/preservation.json +++ b/examples/production/expected/verify/preserve/preservation.json @@ -1 +1 @@ -{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":2450,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0","program":{"byte_length":338,"sha256":"938b367cd5b23f8fb66adc8d4520333ff0e34954395668d2e3b072af86ad3216"},"renderings":[{"byte_length":2119,"composed":{"byte_length":1733,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore","sha256":"6e75f3e535989fc32bb989cf4c7805b106ae68c37c20d39e44ef29d001ee32c1","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore.root"},"crate":{"byte_length":3976,"sha256":"a9ae0afab91c841fada5f7d20ccfe8a41dfc2ca90b5b46dab280d5cd17d1385f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore","sha256":"139fd44341f69af2e846cae06a4aa3638a7ceccfe05bd1b355351a1e0fba9283","target":"rust-core","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore.root"},{"byte_length":2116,"composed":{"byte_length":1728,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd","sha256":"c404ad9e926a4904d9128864a2bc721daa4ab8b07c7ffdb4d60735a862e9749c","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd.root"},"crate":{"byte_length":12894,"sha256":"9b5d12145ec61a1e7c8b36c9ae4a493ad5897ccaf7c764cbf360f4e9a6cea8e6"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd","sha256":"5061f52c2dbdee147771b3cad6f1e674e1d87211987879ae5a051f8921bda45c","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd.root"}],"root":"Production.Main.checkedSum","sha256":"8b5ec0616ccd426df9477826f9e6c2887fd572b661d0cc144dfb1503e710f7db","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.root"},{"byte_length":6583,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1","program":{"byte_length":1055,"sha256":"f21fc970908e57448e4db7c06bf2b57fee84f4b8734cbbf1ac327c6ee4ab6215"},"renderings":[{"byte_length":6377,"composed":{"byte_length":2667,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore","sha256":"83bfcb722475ac9f914442ad5292ff1548c639720aed81fc68da92729fdf7e61","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore.root"},"crate":{"byte_length":4405,"sha256":"ca17d7510141e6e1b02dccc85a256a77785a5103f5a826747ea80ab9c1fb86bd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore","sha256":"ce8b5b07750d04f1061f487898093d4419cb5aa03e38896f0defc58d9e0ec7fc","target":"rust-core","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.root"},{"byte_length":6374,"composed":{"byte_length":2659,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd","sha256":"34746702f48fd5d16ae8385492c3c206c36ef4419504cbd248351333da0ab540","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd.root"},"crate":{"byte_length":13323,"sha256":"513d47124349518781071d810b7d6ee6eda7aad8ae16d6d0fb34990f19bb55f7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd","sha256":"2194db2e7d8a3f6aff1e7ed6f5be83482eba4f0042fa2c9babd986de7fc6da2a","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.root"}],"root":"Production.Main.shapeArea","sha256":"44625f6d916d52df47aaa8aa8f01f6ffd4ed41152f7f133b78b4025cae77b994","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.root"},{"byte_length":4724,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2","program":{"byte_length":725,"sha256":"6853b4945864259f1da2a6fc5277607d3e4c3c725d8be3dfd7cd38000ab16928"},"renderings":[{"byte_length":4438,"composed":{"byte_length":1510,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore","sha256":"0024f2a10d44464a1d3cf748d54acda4d79eb2eed8e68604c7fac066280e4ca9","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore.root"},"crate":{"byte_length":4314,"sha256":"8a91ac04eaa493de8edac523d3ac4a799351d7a2b214f2eb1badeb0ac9fbdfa8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore","sha256":"1c1b771734648e15a641bbecfd9b0eae58e118dea183375e1c612b82ec77d5e3","target":"rust-core","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore.root"},{"byte_length":4435,"composed":{"byte_length":1505,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd","sha256":"5f848b0c32e7bbc9b7a0d5a47423b0068436f7005af3ddac50cc11f214b58c38","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd.root"},"crate":{"byte_length":13232,"sha256":"60e3d73c22b61aae4921ed8290cc78aa71cefc726f1d940ccac0d9daa1da7b37"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd","sha256":"c16edc7a032e7d60f1426275f6709c3fb6509de36038da13b4e73d457f245eab","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd.root"}],"root":"Production.Main.quadruple","sha256":"94083fdca976cf3f85bba04455a2723d6b9fd189847007c85cbad050ceeaa71d","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.root"},{"byte_length":5629,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3","program":{"byte_length":962,"sha256":"4e73456e09ab92d80df1297c17a2a129e17822ff1c88cc30ec946ac7b5d21df3"},"renderings":[{"byte_length":5904,"composed":{"byte_length":1516,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore","sha256":"4ca52b1641f0358be5289dfae22c674f11dd2f5ca4a5b67fad0696fa2f65c8f4","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore.root"},"crate":{"byte_length":4245,"sha256":"5d0c2369b0094a573935f6f3e8ec55ee8377e2716cdf91f69eafbdccfd576350"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore","sha256":"92458bd0195fe7cea801dad8a943dca2a8fba3beccf00136bf139ac2d10ff3d8","target":"rust-core","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore.root"},{"byte_length":5901,"composed":{"byte_length":1511,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd","sha256":"ce8485a20e0602adbc1918bb0c2a2f6d875307e477b452136af4c16fd8b7fa3b","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd.root"},"crate":{"byte_length":13163,"sha256":"0e3de250af7f0d8ab8b78cf05b26a348482821e96656854d81acde5d0045176d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd","sha256":"bedd4e75637e3889d09e269c88a7009132150ac6f4aba163ff944988387fe261","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd.root"}],"root":"Production.Main.halvings","sha256":"698b0a63ae5c1ff85749ccc1b959d680d64d537a4b861a1bc3a37d4f08afadd4","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.root"},{"byte_length":3911,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4","program":{"byte_length":730,"sha256":"8ff4684c89e1a22e97417561a676319cab5351c711d244d980c53acc6160e821"},"renderings":[{"byte_length":4099,"composed":{"byte_length":1637,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd","sha256":"a574cbb7ab687d67b60eb3ed90c67eedaf4a8648dfcbf121386b5c68ee3850dc","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd.root"},"crate":{"byte_length":13085,"sha256":"83b2d122dec85436570c0f5b42cf87a311265a21df42e733c2f90555a4797e2e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd","sha256":"d1dc29edf4465065aab131162bbaa944ba573e9d3074085fefae5aab9e0d0f82","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd.root"}],"root":"Production.Main.sumAll","sha256":"08e527c12338c4497b8fa7e0f3d50ddeb7c50742f2b548b9bfa84a68598d4c48","targets":["rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.root"},{"byte_length":4321,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5","program":{"byte_length":645,"sha256":"fd195b2e7a605141c794aa55f45159309d1e64be3c91ea5076f013e04dd08ec8"},"renderings":[{"byte_length":3226,"composed":{"byte_length":1638,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd","sha256":"5f391c98d41e0a5319aca542152e880daf93a9b83dfdc564a93f8d81be9bfd41","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd.root"},"crate":{"byte_length":13019,"sha256":"0d6a4f61233b7dba3058013d7ce78e556bdbb28e9cd31915fdf5c2be8bcca08a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd","sha256":"ffd4d1d6d40f4210afb0111de54528b57a8b25cc4f558206ca42ba275d018f53","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd.root"}],"root":"Production.Main.headOr","sha256":"fa5dccdbe396b87bb1ac77ce6bac29f4bc11ebc6832de5fce956bfd47afca3af","targets":["rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":2450,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0","program":{"byte_length":338,"sha256":"938b367cd5b23f8fb66adc8d4520333ff0e34954395668d2e3b072af86ad3216"},"renderings":[{"byte_length":2119,"composed":{"byte_length":13344,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore","sha256":"f07d0dd571ebb4156a535b36d1f1943bda333cb649faa7fc9608697964d9bb41","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore.root"},"crate":{"byte_length":3976,"sha256":"a9ae0afab91c841fada5f7d20ccfe8a41dfc2ca90b5b46dab280d5cd17d1385f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore","sha256":"139fd44341f69af2e846cae06a4aa3638a7ceccfe05bd1b355351a1e0fba9283","target":"rust-core","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore.root"},{"byte_length":2116,"composed":{"byte_length":13335,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd","sha256":"172b93f4731141d17b266e88bdf60361c818db90b6d3051f0f0eb6db84385029","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd.root"},"crate":{"byte_length":12894,"sha256":"9b5d12145ec61a1e7c8b36c9ae4a493ad5897ccaf7c764cbf360f4e9a6cea8e6"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd","sha256":"5061f52c2dbdee147771b3cad6f1e674e1d87211987879ae5a051f8921bda45c","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd.root"}],"root":"Production.Main.checkedSum","sha256":"8b5ec0616ccd426df9477826f9e6c2887fd572b661d0cc144dfb1503e710f7db","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.root"},{"byte_length":6583,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1","program":{"byte_length":1055,"sha256":"f21fc970908e57448e4db7c06bf2b57fee84f4b8734cbbf1ac327c6ee4ab6215"},"renderings":[{"byte_length":6377,"composed":{"byte_length":16804,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore","sha256":"7c971298a791fa1b0a3da56dfcd3a9df87c4dc6a89dd9d5d6484401642f88b58","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore.root"},"crate":{"byte_length":4405,"sha256":"ca17d7510141e6e1b02dccc85a256a77785a5103f5a826747ea80ab9c1fb86bd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore","sha256":"ce8b5b07750d04f1061f487898093d4419cb5aa03e38896f0defc58d9e0ec7fc","target":"rust-core","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.root"},{"byte_length":6374,"composed":{"byte_length":16791,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd","sha256":"3757ac3bfcc168e7ee948474437aadc40fcced94694b9d30febba2702032f9ba","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd.root"},"crate":{"byte_length":13323,"sha256":"513d47124349518781071d810b7d6ee6eda7aad8ae16d6d0fb34990f19bb55f7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd","sha256":"2194db2e7d8a3f6aff1e7ed6f5be83482eba4f0042fa2c9babd986de7fc6da2a","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.root"}],"root":"Production.Main.shapeArea","sha256":"44625f6d916d52df47aaa8aa8f01f6ffd4ed41152f7f133b78b4025cae77b994","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.root"},{"byte_length":4724,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2","program":{"byte_length":725,"sha256":"6853b4945864259f1da2a6fc5277607d3e4c3c725d8be3dfd7cd38000ab16928"},"renderings":[{"byte_length":4438,"composed":{"byte_length":12040,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore","sha256":"baf85318d862667e6ea22245a1f15f7a75a36f771e609f4bae37210f882a6d47","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore.root"},"crate":{"byte_length":4314,"sha256":"8a91ac04eaa493de8edac523d3ac4a799351d7a2b214f2eb1badeb0ac9fbdfa8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore","sha256":"1c1b771734648e15a641bbecfd9b0eae58e118dea183375e1c612b82ec77d5e3","target":"rust-core","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore.root"},{"byte_length":4435,"composed":{"byte_length":12029,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd","sha256":"2c0bf26e16092fe32a6426c6e79eda99104f358978e746a0b1c30d50079821f5","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd.root"},"crate":{"byte_length":13232,"sha256":"60e3d73c22b61aae4921ed8290cc78aa71cefc726f1d940ccac0d9daa1da7b37"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd","sha256":"c16edc7a032e7d60f1426275f6709c3fb6509de36038da13b4e73d457f245eab","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd.root"}],"root":"Production.Main.quadruple","sha256":"94083fdca976cf3f85bba04455a2723d6b9fd189847007c85cbad050ceeaa71d","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.root"},{"byte_length":5629,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3","program":{"byte_length":962,"sha256":"4e73456e09ab92d80df1297c17a2a129e17822ff1c88cc30ec946ac7b5d21df3"},"renderings":[{"byte_length":5904,"composed":{"byte_length":12041,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore","sha256":"771e53de58a80feac4c3fbd95c1dab96ecb1cb3d73ae828ced56d7b2300e03ed","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore.root"},"crate":{"byte_length":4245,"sha256":"5d0c2369b0094a573935f6f3e8ec55ee8377e2716cdf91f69eafbdccfd576350"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore","sha256":"92458bd0195fe7cea801dad8a943dca2a8fba3beccf00136bf139ac2d10ff3d8","target":"rust-core","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore.root"},{"byte_length":5901,"composed":{"byte_length":12030,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd","sha256":"7cc1ec26f0fe0264c5274fac2c216d2f7baa7f6587a3acbcdda291e414ed8226","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd.root"},"crate":{"byte_length":13163,"sha256":"0e3de250af7f0d8ab8b78cf05b26a348482821e96656854d81acde5d0045176d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd","sha256":"bedd4e75637e3889d09e269c88a7009132150ac6f4aba163ff944988387fe261","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd.root"}],"root":"Production.Main.halvings","sha256":"698b0a63ae5c1ff85749ccc1b959d680d64d537a4b861a1bc3a37d4f08afadd4","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.root"},{"byte_length":3911,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4","program":{"byte_length":730,"sha256":"8ff4684c89e1a22e97417561a676319cab5351c711d244d980c53acc6160e821"},"renderings":[{"byte_length":4099,"composed":{"byte_length":13516,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd","sha256":"6a89e3c66802bda3a36110b0bc7e5c0bb18d3c63cbc86b409a34f287accef47a","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd.root"},"crate":{"byte_length":13085,"sha256":"83b2d122dec85436570c0f5b42cf87a311265a21df42e733c2f90555a4797e2e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd","sha256":"d1dc29edf4465065aab131162bbaa944ba573e9d3074085fefae5aab9e0d0f82","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd.root"}],"root":"Production.Main.sumAll","sha256":"08e527c12338c4497b8fa7e0f3d50ddeb7c50742f2b548b9bfa84a68598d4c48","targets":["rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.root"},{"byte_length":4321,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5","program":{"byte_length":645,"sha256":"fd195b2e7a605141c794aa55f45159309d1e64be3c91ea5076f013e04dd08ec8"},"renderings":[{"byte_length":3226,"composed":{"byte_length":13517,"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd","sha256":"26ddd507c0e87a33fbe630fb638fb9d0962e3bf42dd0fd2d242ff0590c7c545d","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd.root"},"crate":{"byte_length":13019,"sha256":"0d6a4f61233b7dba3058013d7ce78e556bdbb28e9cd31915fdf5c2be8bcca08a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd","sha256":"ffd4d1d6d40f4210afb0111de54528b57a8b25cc4f558206ca42ba275d018f53","target":"rust-std","theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd.root"}],"root":"Production.Main.headOr","sha256":"fa5dccdbe396b87bb1ac77ce6bac29f4bc11ebc6832de5fce956bfd47afca3af","targets":["rust-std"],"theorem":"LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.root"}],"spec":"lexlean/preservation/1"} diff --git a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Audit.json index 0e9dd66b2..d3c28af83 100644 --- a/examples/production/expected/verify/process/preserve/LexLeanPreserve.Audit.json +++ b/examples/production/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"d7a85edd5e75a9e53a2badee61d84495f296bfa210ceac7631ace90ce26c0f7b","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R1.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"8361b4f674fcadd663671566d19da4f1c0e7d3773ca27ea1b1b0d663a5065780","tool":"lean"} diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R0/Compose/RustCore.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R0/Compose/RustCore.lean deleted file mode 100644 index 2159a4aa7..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R0/Compose/RustCore.lean +++ /dev/null @@ -1,32 +0,0 @@ -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0 -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore - -theorem __wt_0 : ∀ (__s : (Reasoning.Clinic.Vitals)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.__enc_0 __s) (.adt 0) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).temperature) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).heartRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).respiratoryRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).whiteCells) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).systolic) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).infection) _root_.LexLeanPreservation.Rust.wtl_nil)))))) - -theorem __wt_1 : ∀ (__s : (Reasoning.Clinic.Chart)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.__enc_1 __s) (.adt 1) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 (__s).vitals) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).fever) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).tachycardia) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).tachypnea) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).leukocytosis) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).sirs) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).sepsis) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).shock) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).level) _root_.LexLeanPreservation.Rust.wtl_nil))))))))) - -theorem __wt_2 : ∀ (__v : (Reasoning.Clinic.Triage.Step)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.__enc_2 __v) (.adt 2) - | Reasoning.Clinic.Triage.Step.Fever => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Tachycardia => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Tachypnea => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Leukocytosis => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Sirs => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Sepsis => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Shock => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Escalate => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteCells : Nat) (systolic : Nat) (infection : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.denote temperature heartRate respiratoryRate whiteCells systolic infection) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat temperature) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat heartRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat respiratoryRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat whiteCells) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat systolic) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat infection) _root_.LexLeanPreservation.Rust.wtl_nil)))))) rfl rfl (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.root temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R0/Compose/RustCore.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R0/Compose/RustCore.lex.tex new file mode 100644 index 000000000..3db189929 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R0/Compose/RustCore.lex.tex @@ -0,0 +1,1341 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0, + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_1 : @724 := @1388 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_2 : @1396 := @1631 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.root : @2716 := @2717 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.program +@1 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.krate +@2 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.flags +@3 := Reasoning.Clinic.Vitals +@4 := #0 +@5 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@16 := (__s : @3) -> @13 @6 @10 +@17 := Reasoning.Clinic.Vitals.temperature +@18 := @17 @4 +@19 := Reasoning.Clinic.Vitals.heartRate +@20 := @19 @4 +@21 := Reasoning.Clinic.Vitals.respiratoryRate +@22 := @21 @4 +@23 := Reasoning.Clinic.Vitals.whiteCells +@24 := @23 @4 +@25 := Reasoning.Clinic.Vitals.systolic +@26 := @25 @4 +@27 := Reasoning.Clinic.Vitals.infection +@28 := @27 @4 +@29 := LexLeanTarget.TargetSyntax.Value.nat +@30 := @29 @18 +@31 := LexLeanTarget.TargetSyntax.Ty.nat +@32 := LexLeanTarget.TargetSyntax.Program +@33 := LexLeanPreservation.Rust.RCrate +@34 := LexLeanPreservation.Rust.Flags +@35 := Nat +@36 := #3 +@37 := @7 @36 +@38 := #2 +@39 := @37 @38 +@40 := #1 +@41 := @39 @40 +@42 := @29 @4 +@48 := {p : @32} -> {c : @33} -> {A : @34} -> (n : @35) -> @41 @42 @31 +@50 := LexLeanPreservation.Rust.wt_nat @0 +@57 := {c : @33} -> {A : @34} -> (n : @35) -> @11 @38 @40 @42 @31 +@58 := @50 @1 +@63 := {A : @34} -> (n : @35) -> @12 @40 @42 @31 +@64 := @58 @2 +@67 := (n : @35) -> @13 @42 @31 +@68 := @64 @18 +@70 := @13 @30 @31 +@71 := @29 @20 +@72 := @64 @20 +@74 := @13 @71 @31 +@75 := @29 @22 +@76 := @64 @22 +@78 := @13 @75 @31 +@79 := @29 @24 +@80 := @64 @24 +@82 := @13 @79 @31 +@83 := @29 @26 +@84 := @64 @26 +@86 := @13 @83 @31 +@87 := @29 @28 +@88 := @64 @28 +@90 := @13 @87 @31 +@91 := LexLeanTarget.TargetSyntax.Value +@92 := LexLeanTarget.TargetSyntax.Ty +@93 := List.nil.{0} +@94 := List.cons.{0} +@95 := @93 @91 +@96 := @94 @91 +@98 := @96 @87 @95 +@100 := @96 @83 @98 +@102 := @96 @79 @100 +@104 := @96 @75 @102 +@106 := @96 @71 @104 +@108 := @96 @30 @106 +@109 := @93 @92 +@110 := @94 @92 +@111 := @110 @31 +@112 := @111 @109 +@113 := @111 @112 +@114 := @111 @113 +@115 := @111 @114 +@116 := @111 @115 +@117 := @111 @116 +@118 := LexLeanPreservation.Rust.WTL +@126 := {p : @32} -> {c : @33} -> {A : @34} -> @118 @38 @40 @4 @95 @109 +@128 := LexLeanPreservation.Rust.wtl_nil @0 +@129 := @118 @0 +@135 := {c : @33} -> {A : @34} -> @129 @40 @4 @95 @109 +@136 := @128 @1 +@137 := @129 @1 +@141 := {A : @34} -> @137 @4 @95 @109 +@142 := @136 @2 +@143 := @137 @2 +@144 := @143 @95 +@145 := @144 @109 +@146 := List.{0} +@147 := @146 @91 +@148 := @146 @92 +@149 := #6 +@150 := @7 @149 +@151 := #5 +@152 := @150 @151 +@153 := #4 +@156 := @152 @153 @36 @38 +@157 := #7 +@162 := @118 @157 @149 @151 @38 @40 +@163 := #8 +@166 := @118 @163 @157 @149 +@168 := @96 @151 @36 +@169 := @166 @168 +@171 := @110 @153 @38 +@181 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {v : @91} -> {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @156) -> (hs : @162) -> @169 @171 +@183 := LexLeanPreservation.Rust.wtl_cons @0 +@187 := @11 @151 @153 @36 @38 +@191 := @129 @149 @151 @38 @40 +@203 := {c : @33} -> + {A : @34} -> + {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @187) -> (hs : @191) -> @129 @157 @149 @168 @171 +@204 := @183 @1 +@207 := @12 @153 @36 @38 +@210 := @137 @151 @38 @40 +@220 := {A : @34} -> + {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @207) -> (hs : @210) -> @137 @149 @168 @171 +@221 := @204 @2 +@223 := @13 @36 @38 +@225 := @143 @38 @40 +@233 := {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @223) -> (hs : @225) -> @143 @168 @171 +@234 := @221 @87 +@236 := @29 (@27 @36) +@249 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @236 @38) -> (hs : @225) -> @143 (@96 (@29 (@27 @151)) @36) @171 +@250 := @234 @31 +@252 := @29 (@27 @38) +@254 := @13 @252 @31 +@259 := @143 (@96 (@29 (@27 @153)) @36) +@260 := @111 @38 +@265 := {vs : @147} -> {ts : @148} -> (h : @254) -> (hs : @225) -> @259 @260 +@266 := @250 @95 +@268 := @29 (@27 @40) +@270 := @13 @268 @31 +@271 := @144 @40 +@273 := @96 @236 @95 +@278 := {ts : @148} -> (h : @270) -> (hs : @271) -> @143 @273 @260 +@279 := @266 @109 +@281 := @96 @252 @95 +@282 := @143 @281 +@285 := (h : @90) -> (hs : @145) -> @282 @112 +@286 := @279 @88 +@288 := @96 @268 @95 +@290 := @143 @288 @112 +@291 := (hs : @145) -> @290 +@292 := @286 @142 +@294 := @143 @98 @112 +@295 := @221 @83 +@297 := @29 (@25 @36) +@310 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @297 @38) -> (hs : @225) -> @143 (@96 (@29 (@25 @151)) @36) @171 +@311 := @295 @31 +@313 := @29 (@25 @38) +@325 := {vs : @147} -> + {ts : @148} -> (h : @13 @313 @31) -> (hs : @225) -> @143 (@96 (@29 (@25 @153)) @36) @260 +@326 := @311 @98 +@328 := @29 (@25 @40) +@330 := @13 @328 @31 +@331 := @282 @40 +@333 := @96 @297 @273 +@338 := {ts : @148} -> (h : @330) -> (hs : @331) -> @143 @333 @260 +@339 := @326 @112 +@341 := @96 @313 @281 +@342 := @143 @341 +@345 := (h : @86) -> (hs : @290) -> @342 @113 +@346 := @339 @84 +@348 := @96 @328 @288 +@350 := @143 @348 @113 +@351 := (hs : @294) -> @350 +@352 := @346 @292 +@354 := @143 @100 @113 +@355 := @221 @79 +@357 := @29 (@23 @36) +@370 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @357 @38) -> (hs : @225) -> @143 (@96 (@29 (@23 @151)) @36) @171 +@371 := @355 @31 +@373 := @29 (@23 @38) +@385 := {vs : @147} -> + {ts : @148} -> (h : @13 @373 @31) -> (hs : @225) -> @143 (@96 (@29 (@23 @153)) @36) @260 +@386 := @371 @100 +@388 := @29 (@23 @40) +@390 := @13 @388 @31 +@391 := @342 @40 +@393 := @96 @357 @333 +@398 := {ts : @148} -> (h : @390) -> (hs : @391) -> @143 @393 @260 +@399 := @386 @113 +@401 := @96 @373 @341 +@402 := @143 @401 +@405 := (h : @82) -> (hs : @350) -> @402 @114 +@406 := @399 @80 +@408 := @96 @388 @348 +@410 := @143 @408 @114 +@411 := (hs : @354) -> @410 +@412 := @406 @352 +@414 := @143 @102 @114 +@415 := @221 @75 +@417 := @29 (@21 @36) +@430 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @417 @38) -> (hs : @225) -> @143 (@96 (@29 (@21 @151)) @36) @171 +@431 := @415 @31 +@433 := @29 (@21 @38) +@445 := {vs : @147} -> + {ts : @148} -> (h : @13 @433 @31) -> (hs : @225) -> @143 (@96 (@29 (@21 @153)) @36) @260 +@446 := @431 @102 +@448 := @29 (@21 @40) +@450 := @13 @448 @31 +@451 := @402 @40 +@453 := @96 @417 @393 +@458 := {ts : @148} -> (h : @450) -> (hs : @451) -> @143 @453 @260 +@459 := @446 @114 +@461 := @96 @433 @401 +@462 := @143 @461 +@465 := (h : @78) -> (hs : @410) -> @462 @115 +@466 := @459 @76 +@468 := @96 @448 @408 +@470 := @143 @468 @115 +@471 := (hs : @414) -> @470 +@472 := @466 @412 +@474 := @143 @104 @115 +@475 := @221 @71 +@477 := @29 (@19 @36) +@490 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @477 @38) -> (hs : @225) -> @143 (@96 (@29 (@19 @151)) @36) @171 +@491 := @475 @31 +@493 := @29 (@19 @38) +@505 := {vs : @147} -> + {ts : @148} -> (h : @13 @493 @31) -> (hs : @225) -> @143 (@96 (@29 (@19 @153)) @36) @260 +@506 := @491 @104 +@508 := @29 (@19 @40) +@510 := @13 @508 @31 +@511 := @462 @40 +@513 := @96 @477 @453 +@518 := {ts : @148} -> (h : @510) -> (hs : @511) -> @143 @513 @260 +@519 := @506 @115 +@521 := @96 @493 @461 +@522 := @143 @521 +@525 := (h : @74) -> (hs : @470) -> @522 @116 +@526 := @519 @72 +@528 := @96 @508 @468 +@530 := @143 @528 @116 +@531 := (hs : @474) -> @530 +@532 := @526 @472 +@534 := @143 @106 @116 +@535 := @221 @30 +@537 := @29 (@17 @36) +@550 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @537 @38) -> (hs : @225) -> @143 (@96 (@29 (@17 @151)) @36) @171 +@551 := @535 @31 +@553 := @29 (@17 @38) +@565 := {vs : @147} -> + {ts : @148} -> (h : @13 @553 @31) -> (hs : @225) -> @143 (@96 (@29 (@17 @153)) @36) @260 +@566 := @551 @106 +@568 := @29 (@17 @40) +@570 := @13 @568 @31 +@571 := @522 @40 +@573 := @96 @537 @513 +@578 := {ts : @148} -> (h : @570) -> (hs : @571) -> @143 @573 @260 +@579 := @566 @116 +@581 := @96 @553 @521 +@582 := @143 @581 +@585 := (h : @70) -> (hs : @530) -> @582 @117 +@586 := @579 @68 +@588 := @96 @568 @528 +@590 := @143 @588 @117 +@591 := (hs : @534) -> @590 +@592 := @586 @532 +@594 := @143 @108 @117 +@595 := Eq.{1} +@596 := Option.{0} +@597 := @596 @148 +@598 := @595 @597 +@599 := LexLeanPreservation.Rust.adtFields +@603 := @598 (@599 @149 @36 @38) +@604 := Option.some.{0} +@605 := @604 @148 +@606 := @605 @4 +@607 := @603 @606 +@610 := @7 @163 @157 @149 +@611 := LexLeanTarget.TargetSyntax.Value.adt +@613 := @611 @153 @36 +@614 := @610 @613 +@615 := @8 @151 +@625 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {i : @35} -> {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @607) -> (hf : @162) -> @614 @615 +@627 := LexLeanPreservation.Rust.wt_adt @0 +@628 := @599 @0 +@632 := @598 (@628 @36 @38) @606 +@644 := {c : @33} -> + {A : @34} -> + {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @191) -> @11 @157 @149 @613 @615 +@645 := @627 @1 +@655 := {A : @34} -> + {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @210) -> @12 @149 @613 @615 +@656 := @645 @2 +@657 := @13 @613 +@664 := {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @225) -> @657 @615 +@665 := @656 @9 +@666 := @628 @9 +@675 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@666 @38) @606) -> (hf : @225) -> @657 @10 +@676 := @665 @9 +@677 := @666 @9 +@678 := @598 @677 +@679 := @678 @606 +@680 := @611 @9 +@682 := @13 (@680 @36) +@687 := {fs : @147} -> {tys : @148} -> (h : @679) -> (hf : @225) -> @682 @10 +@688 := @676 @108 +@695 := {tys : @148} -> (h : @679) -> (hf : @582 @40) -> @13 (@680 @573) @10 +@696 := @688 @117 +@703 := (h : @678 (@605 @117)) -> (hf : @590) -> @13 (@680 @581) @10 +@704 := Eq.refl.{1} +@705 := @704 @597 +@707 := @696 (@705 @677) +@711 := (hf : @594) -> @13 (@680 @588) @10 +@712 := @707 @592 +@715 := @13 (@680 @108) @10 +@716 := fun (__s : @3) => @712 +@717 := Reasoning.Clinic.Chart +@719 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.__enc_1 @4 +@720 := 1 +@721 := @8 @720 +@724 := (__s : @717) -> @13 @719 @721 +@725 := Reasoning.Clinic.Chart.vitals +@726 := @725 @4 +@727 := Reasoning.Clinic.Chart.fever +@728 := @727 @4 +@729 := Reasoning.Clinic.Chart.tachycardia +@730 := @729 @4 +@731 := Reasoning.Clinic.Chart.tachypnea +@732 := @731 @4 +@733 := Reasoning.Clinic.Chart.leukocytosis +@734 := @733 @4 +@735 := Reasoning.Clinic.Chart.sirs +@736 := @735 @4 +@737 := Reasoning.Clinic.Chart.sepsis +@738 := @737 @4 +@739 := Reasoning.Clinic.Chart.shock +@740 := @739 @4 +@741 := Reasoning.Clinic.Chart.level +@742 := @741 @4 +@743 := @5 @726 +@745 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_0 @726 +@746 := @29 @728 +@747 := @64 @728 +@749 := @13 @746 @31 +@750 := @29 @730 +@751 := @64 @730 +@753 := @13 @750 @31 +@754 := @29 @732 +@755 := @64 @732 +@757 := @13 @754 @31 +@758 := @29 @734 +@759 := @64 @734 +@761 := @13 @758 @31 +@762 := @29 @736 +@763 := @64 @736 +@765 := @13 @762 @31 +@766 := @29 @738 +@767 := @64 @738 +@769 := @13 @766 @31 +@770 := @29 @740 +@771 := @64 @740 +@773 := @13 @770 @31 +@774 := @29 @742 +@775 := @64 @742 +@777 := @13 @774 @31 +@779 := @96 @774 @95 +@781 := @96 @770 @779 +@783 := @96 @766 @781 +@785 := @96 @762 @783 +@787 := @96 @758 @785 +@789 := @96 @754 @787 +@791 := @96 @750 @789 +@793 := @96 @746 @791 +@795 := @96 @743 @793 +@796 := @111 @117 +@797 := @111 @796 +@798 := @110 @10 +@799 := @798 @797 +@800 := @221 @774 +@802 := @29 (@741 @36) +@815 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @802 @38) -> (hs : @225) -> @143 (@96 (@29 (@741 @151)) @36) @171 +@816 := @800 @31 +@818 := @29 (@741 @38) +@830 := {vs : @147} -> + {ts : @148} -> (h : @13 @818 @31) -> (hs : @225) -> @143 (@96 (@29 (@741 @153)) @36) @260 +@831 := @816 @95 +@833 := @29 (@741 @40) +@835 := @13 @833 @31 +@837 := @96 @802 @95 +@842 := {ts : @148} -> (h : @835) -> (hs : @271) -> @143 @837 @260 +@843 := @831 @109 +@845 := @96 @818 @95 +@846 := @143 @845 +@849 := (h : @777) -> (hs : @145) -> @846 @112 +@850 := @843 @775 +@852 := @96 @833 @95 +@854 := @143 @852 @112 +@855 := (hs : @145) -> @854 +@856 := @850 @142 +@858 := @143 @779 @112 +@859 := @221 @770 +@861 := @29 (@739 @36) +@874 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @861 @38) -> (hs : @225) -> @143 (@96 (@29 (@739 @151)) @36) @171 +@875 := @859 @31 +@877 := @29 (@739 @38) +@889 := {vs : @147} -> + {ts : @148} -> (h : @13 @877 @31) -> (hs : @225) -> @143 (@96 (@29 (@739 @153)) @36) @260 +@890 := @875 @779 +@892 := @29 (@739 @40) +@894 := @13 @892 @31 +@895 := @846 @40 +@897 := @96 @861 @837 +@902 := {ts : @148} -> (h : @894) -> (hs : @895) -> @143 @897 @260 +@903 := @890 @112 +@905 := @96 @877 @845 +@906 := @143 @905 +@909 := (h : @773) -> (hs : @854) -> @906 @113 +@910 := @903 @771 +@912 := @96 @892 @852 +@914 := @143 @912 @113 +@915 := (hs : @858) -> @914 +@916 := @910 @856 +@918 := @143 @781 @113 +@919 := @221 @766 +@921 := @29 (@737 @36) +@934 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @921 @38) -> (hs : @225) -> @143 (@96 (@29 (@737 @151)) @36) @171 +@935 := @919 @31 +@937 := @29 (@737 @38) +@949 := {vs : @147} -> + {ts : @148} -> (h : @13 @937 @31) -> (hs : @225) -> @143 (@96 (@29 (@737 @153)) @36) @260 +@950 := @935 @781 +@952 := @29 (@737 @40) +@954 := @13 @952 @31 +@955 := @906 @40 +@957 := @96 @921 @897 +@962 := {ts : @148} -> (h : @954) -> (hs : @955) -> @143 @957 @260 +@963 := @950 @113 +@965 := @96 @937 @905 +@966 := @143 @965 +@969 := (h : @769) -> (hs : @914) -> @966 @114 +@970 := @963 @767 +@972 := @96 @952 @912 +@974 := @143 @972 @114 +@975 := (hs : @918) -> @974 +@976 := @970 @916 +@978 := @143 @783 @114 +@979 := @221 @762 +@981 := @29 (@735 @36) +@994 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @981 @38) -> (hs : @225) -> @143 (@96 (@29 (@735 @151)) @36) @171 +@995 := @979 @31 +@997 := @29 (@735 @38) +@1009 := {vs : @147} -> + {ts : @148} -> (h : @13 @997 @31) -> (hs : @225) -> @143 (@96 (@29 (@735 @153)) @36) @260 +@1010 := @995 @783 +@1012 := @29 (@735 @40) +@1014 := @13 @1012 @31 +@1015 := @966 @40 +@1017 := @96 @981 @957 +@1022 := {ts : @148} -> (h : @1014) -> (hs : @1015) -> @143 @1017 @260 +@1023 := @1010 @114 +@1025 := @96 @997 @965 +@1026 := @143 @1025 +@1029 := (h : @765) -> (hs : @974) -> @1026 @115 +@1030 := @1023 @763 +@1032 := @96 @1012 @972 +@1034 := @143 @1032 @115 +@1035 := (hs : @978) -> @1034 +@1036 := @1030 @976 +@1038 := @143 @785 @115 +@1039 := @221 @758 +@1041 := @29 (@733 @36) +@1054 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1041 @38) -> (hs : @225) -> @143 (@96 (@29 (@733 @151)) @36) @171 +@1055 := @1039 @31 +@1057 := @29 (@733 @38) +@1069 := {vs : @147} -> + {ts : @148} -> (h : @13 @1057 @31) -> (hs : @225) -> @143 (@96 (@29 (@733 @153)) @36) @260 +@1070 := @1055 @785 +@1072 := @29 (@733 @40) +@1074 := @13 @1072 @31 +@1075 := @1026 @40 +@1077 := @96 @1041 @1017 +@1082 := {ts : @148} -> (h : @1074) -> (hs : @1075) -> @143 @1077 @260 +@1083 := @1070 @115 +@1085 := @96 @1057 @1025 +@1086 := @143 @1085 +@1089 := (h : @761) -> (hs : @1034) -> @1086 @116 +@1090 := @1083 @759 +@1092 := @96 @1072 @1032 +@1094 := @143 @1092 @116 +@1095 := (hs : @1038) -> @1094 +@1096 := @1090 @1036 +@1098 := @143 @787 @116 +@1099 := @221 @754 +@1101 := @29 (@731 @36) +@1114 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1101 @38) -> (hs : @225) -> @143 (@96 (@29 (@731 @151)) @36) @171 +@1115 := @1099 @31 +@1117 := @29 (@731 @38) +@1129 := {vs : @147} -> + {ts : @148} -> (h : @13 @1117 @31) -> (hs : @225) -> @143 (@96 (@29 (@731 @153)) @36) @260 +@1130 := @1115 @787 +@1132 := @29 (@731 @40) +@1134 := @13 @1132 @31 +@1135 := @1086 @40 +@1137 := @96 @1101 @1077 +@1142 := {ts : @148} -> (h : @1134) -> (hs : @1135) -> @143 @1137 @260 +@1143 := @1130 @116 +@1145 := @96 @1117 @1085 +@1146 := @143 @1145 +@1149 := (h : @757) -> (hs : @1094) -> @1146 @117 +@1150 := @1143 @755 +@1152 := @96 @1132 @1092 +@1154 := @143 @1152 @117 +@1155 := (hs : @1098) -> @1154 +@1156 := @1150 @1096 +@1158 := @143 @789 @117 +@1159 := @221 @750 +@1161 := @29 (@729 @36) +@1174 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1161 @38) -> (hs : @225) -> @143 (@96 (@29 (@729 @151)) @36) @171 +@1175 := @1159 @31 +@1177 := @29 (@729 @38) +@1189 := {vs : @147} -> + {ts : @148} -> (h : @13 @1177 @31) -> (hs : @225) -> @143 (@96 (@29 (@729 @153)) @36) @260 +@1190 := @1175 @789 +@1192 := @29 (@729 @40) +@1194 := @13 @1192 @31 +@1195 := @1146 @40 +@1197 := @96 @1161 @1137 +@1202 := {ts : @148} -> (h : @1194) -> (hs : @1195) -> @143 @1197 @260 +@1203 := @1190 @117 +@1205 := @96 @1177 @1145 +@1206 := @143 @1205 +@1209 := (h : @753) -> (hs : @1154) -> @1206 @796 +@1210 := @1203 @751 +@1212 := @96 @1192 @1152 +@1214 := @143 @1212 @796 +@1215 := (hs : @1158) -> @1214 +@1216 := @1210 @1156 +@1218 := @143 @791 @796 +@1219 := @221 @746 +@1221 := @29 (@727 @36) +@1234 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1221 @38) -> (hs : @225) -> @143 (@96 (@29 (@727 @151)) @36) @171 +@1235 := @1219 @31 +@1237 := @29 (@727 @38) +@1249 := {vs : @147} -> + {ts : @148} -> (h : @13 @1237 @31) -> (hs : @225) -> @143 (@96 (@29 (@727 @153)) @36) @260 +@1250 := @1235 @791 +@1252 := @29 (@727 @40) +@1254 := @13 @1252 @31 +@1255 := @1206 @40 +@1257 := @96 @1221 @1197 +@1262 := {ts : @148} -> (h : @1254) -> (hs : @1255) -> @143 @1257 @260 +@1263 := @1250 @796 +@1265 := @96 @1237 @1205 +@1266 := @143 @1265 +@1269 := (h : @749) -> (hs : @1214) -> @1266 @797 +@1270 := @1263 @747 +@1272 := @96 @1252 @1212 +@1274 := @143 @1272 @797 +@1275 := (hs : @1218) -> @1274 +@1276 := @1270 @1216 +@1278 := @143 @793 @797 +@1279 := @221 @743 +@1281 := @5 (@725 @36) +@1294 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1281 @38) -> (hs : @225) -> @143 (@96 (@5 (@725 @151)) @36) @171 +@1295 := @1279 @10 +@1297 := @5 (@725 @38) +@1299 := @13 @1297 @10 +@1304 := @143 (@96 (@5 (@725 @153)) @36) +@1305 := @798 @38 +@1310 := {vs : @147} -> {ts : @148} -> (h : @1299) -> (hs : @225) -> @1304 @1305 +@1311 := @1295 @793 +@1313 := @5 (@725 @40) +@1315 := @13 @1313 @10 +@1316 := @1266 @40 +@1318 := @96 @1281 @1257 +@1323 := {ts : @148} -> (h : @1315) -> (hs : @1316) -> @143 @1318 @1305 +@1324 := @1311 @797 +@1326 := @13 @743 @10 +@1328 := @96 @1297 @1265 +@1329 := @143 @1328 +@1332 := (h : @1326) -> (hs : @1274) -> @1329 @799 +@1333 := @1324 @745 +@1335 := @96 @1313 @1272 +@1337 := @143 @1335 @799 +@1338 := (hs : @1278) -> @1337 +@1339 := @1333 @1276 +@1341 := @143 @795 @799 +@1342 := @656 @720 +@1343 := @628 @720 +@1352 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@1343 @38) @606) -> (hf : @225) -> @657 @721 +@1353 := @1342 @9 +@1354 := @1343 @9 +@1355 := @598 @1354 +@1356 := @1355 @606 +@1361 := {fs : @147} -> {tys : @148} -> (h : @1356) -> (hf : @225) -> @682 @721 +@1362 := @1353 @795 +@1369 := {tys : @148} -> (h : @1356) -> (hf : @1329 @40) -> @13 (@680 @1318) @721 +@1370 := @1362 @799 +@1377 := (h : @1355 (@605 @799)) -> (hf : @1337) -> @13 (@680 @1328) @721 +@1379 := @1370 (@705 @1354) +@1383 := (hf : @1341) -> @13 (@680 @1335) @721 +@1384 := @1379 @1339 +@1387 := @13 (@680 @795) @721 +@1388 := fun (__s : @717) => @1384 +@1389 := Reasoning.Clinic.Triage.Step +@1391 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.__enc_2 @4 +@1392 := 2 +@1393 := @8 @1392 +@1395 := @13 @1391 @1393 +@1396 := (__v : @1389) -> @1395 +@1397 := fun (__v : @1389) => @1395 +@1398 := @656 @1392 +@1399 := @628 @1392 +@1408 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@1399 @38) @606) -> (hf : @225) -> @657 @1393 +@1409 := @1398 @9 +@1410 := @1399 @9 +@1411 := @598 @1410 +@1412 := @1411 @606 +@1417 := {fs : @147} -> {tys : @148} -> (h : @1412) -> (hf : @225) -> @682 @1393 +@1418 := @1409 @95 +@1421 := @13 (@680 @95) @1393 +@1424 := {tys : @148} -> (h : @1412) -> (hf : @271) -> @1421 +@1425 := @1418 @109 +@1426 := @605 @109 +@1429 := (h : @1411 @1426) -> (hf : @145) -> @1421 +@1432 := @1425 (@705 @1410) @142 +@1433 := @1398 @720 +@1434 := @1399 @720 +@1435 := @598 @1434 +@1436 := @1435 @606 +@1437 := @611 @720 +@1444 := {fs : @147} -> {tys : @148} -> (h : @1436) -> (hf : @225) -> @13 (@1437 @36) @1393 +@1445 := @1433 @95 +@1448 := @13 (@1437 @95) @1393 +@1451 := {tys : @148} -> (h : @1436) -> (hf : @271) -> @1448 +@1452 := @1445 @109 +@1455 := (h : @1435 @1426) -> (hf : @145) -> @1448 +@1458 := @1452 (@705 @1434) @142 +@1459 := @1398 @1392 +@1460 := @1399 @1392 +@1461 := @598 @1460 +@1462 := @1461 @606 +@1463 := @611 @1392 +@1470 := {fs : @147} -> {tys : @148} -> (h : @1462) -> (hf : @225) -> @13 (@1463 @36) @1393 +@1471 := @1459 @95 +@1474 := @13 (@1463 @95) @1393 +@1477 := {tys : @148} -> (h : @1462) -> (hf : @271) -> @1474 +@1478 := @1471 @109 +@1481 := (h : @1461 @1426) -> (hf : @145) -> @1474 +@1484 := @1478 (@705 @1460) @142 +@1485 := 3 +@1486 := @1398 @1485 +@1487 := @1399 @1485 +@1488 := @598 @1487 +@1489 := @1488 @606 +@1490 := @611 @1485 +@1497 := {fs : @147} -> {tys : @148} -> (h : @1489) -> (hf : @225) -> @13 (@1490 @36) @1393 +@1498 := @1486 @95 +@1501 := @13 (@1490 @95) @1393 +@1504 := {tys : @148} -> (h : @1489) -> (hf : @271) -> @1501 +@1505 := @1498 @109 +@1508 := (h : @1488 @1426) -> (hf : @145) -> @1501 +@1511 := @1505 (@705 @1487) @142 +@1512 := 4 +@1513 := @1398 @1512 +@1514 := @1399 @1512 +@1515 := @598 @1514 +@1516 := @1515 @606 +@1517 := @611 @1512 +@1524 := {fs : @147} -> {tys : @148} -> (h : @1516) -> (hf : @225) -> @13 (@1517 @36) @1393 +@1525 := @1513 @95 +@1528 := @13 (@1517 @95) @1393 +@1531 := {tys : @148} -> (h : @1516) -> (hf : @271) -> @1528 +@1532 := @1525 @109 +@1535 := (h : @1515 @1426) -> (hf : @145) -> @1528 +@1538 := @1532 (@705 @1514) @142 +@1539 := 5 +@1540 := @1398 @1539 +@1541 := @1399 @1539 +@1542 := @598 @1541 +@1543 := @1542 @606 +@1544 := @611 @1539 +@1551 := {fs : @147} -> {tys : @148} -> (h : @1543) -> (hf : @225) -> @13 (@1544 @36) @1393 +@1552 := @1540 @95 +@1555 := @13 (@1544 @95) @1393 +@1558 := {tys : @148} -> (h : @1543) -> (hf : @271) -> @1555 +@1559 := @1552 @109 +@1562 := (h : @1542 @1426) -> (hf : @145) -> @1555 +@1565 := @1559 (@705 @1541) @142 +@1566 := 6 +@1567 := @1398 @1566 +@1568 := @1399 @1566 +@1569 := @598 @1568 +@1570 := @1569 @606 +@1571 := @611 @1566 +@1578 := {fs : @147} -> {tys : @148} -> (h : @1570) -> (hf : @225) -> @13 (@1571 @36) @1393 +@1579 := @1567 @95 +@1582 := @13 (@1571 @95) @1393 +@1585 := {tys : @148} -> (h : @1570) -> (hf : @271) -> @1582 +@1586 := @1579 @109 +@1589 := (h : @1569 @1426) -> (hf : @145) -> @1582 +@1592 := @1586 (@705 @1568) @142 +@1593 := 7 +@1594 := @1398 @1593 +@1595 := @1399 @1593 +@1596 := @598 @1595 +@1597 := @1596 @606 +@1598 := @611 @1593 +@1605 := {fs : @147} -> {tys : @148} -> (h : @1597) -> (hf : @225) -> @13 (@1598 @36) @1393 +@1606 := @1594 @95 +@1609 := @13 (@1598 @95) @1393 +@1612 := {tys : @148} -> (h : @1597) -> (hf : @271) -> @1609 +@1613 := @1606 @109 +@1616 := (h : @1596 @1426) -> (hf : @145) -> @1609 +@1619 := @1613 (@705 @1595) @142 +@1631 := fun (__v : @1389) => + Reasoning.Clinic.Triage.Step.casesOn.{0} @1397 @4 @1432 @1458 @1484 @1511 @1538 @1565 @1592 @1619 +@1632 := @29 @149 +@1633 := @64 @149 +@1634 := @13 @1632 +@1635 := @1634 @31 +@1636 := @29 @151 +@1637 := @64 @151 +@1638 := @13 @1636 +@1639 := @1638 @31 +@1640 := @29 @153 +@1641 := @64 @153 +@1642 := @13 @1640 +@1643 := @1642 @31 +@1644 := @29 @36 +@1645 := @64 @36 +@1647 := @13 @1644 @31 +@1648 := @29 @38 +@1649 := @64 @38 +@1651 := @13 @1648 @31 +@1652 := @29 @40 +@1653 := @64 @40 +@1655 := @13 @1652 @31 +@1656 := @96 @1652 +@1657 := @1656 @95 +@1658 := @96 @1648 +@1659 := @1658 @1657 +@1660 := @96 @1644 +@1661 := @1660 @1659 +@1662 := @96 @1640 +@1663 := @1662 @1661 +@1664 := @96 @1636 +@1665 := @1664 @1663 +@1666 := @96 @1632 +@1667 := @1666 @1665 +@1670 := Prod.{0, 0} @35 @91 +@1673 := Prod.mk.{0, 0} @35 @91 +@1674 := @1673 @1539 +@1675 := @1674 @1652 +@1676 := @1673 @1512 +@1677 := @1676 @1648 +@1678 := @1673 @1485 +@1679 := @1678 @1644 +@1680 := @1673 @1392 +@1681 := @1680 @1640 +@1682 := @1673 @720 +@1683 := @1682 @1636 +@1684 := @1673 @9 +@1685 := @1684 @1632 +@1686 := @93 @1670 +@1687 := @94 @1670 +@1689 := @1687 @1685 @1686 +@1691 := @1687 @1683 @1689 +@1693 := @1687 @1681 @1691 +@1695 := @1687 @1679 @1693 +@1697 := @1687 @1677 @1695 +@1699 := @1687 @1675 @1697 +@1700 := Bool.true +@1701 := LexLeanTarget.TargetSyntax.Function +@1702 := LexLeanTarget.TargetSyntax.Program.functions +@1703 := @1702 @0 +@1704 := @93 @35 +@1705 := LexLeanTarget.TargetSyntax.Ty.unit +@1706 := LexLeanTarget.TargetSyntax.Value.unit +@1709 := LexLeanTarget.TargetSyntax.Expr.value @1705 @1706 +@1714 := LexLeanTarget.TargetSyntax.Function.mk @1704 @109 @1705 @1709 +@1719 := List.getD.{0} @1701 @1703 @9 @1714 +@1723 := fun (__e_n : @35) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.root @4 @9 +@1724 := @221 @1652 +@1725 := @1642 @38 +@1727 := @143 (@1666 @36) +@1733 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1725) -> (hs : @225) -> @1727 @171 +@1734 := @1724 @31 +@1741 := {vs : @147} -> {ts : @148} -> (h : @1647) -> (hs : @225) -> @143 (@1664 @36) @260 +@1742 := @1734 @95 +@1743 := @1662 @95 +@1748 := {ts : @148} -> (h : @1651) -> (hs : @271) -> @143 @1743 @260 +@1749 := @1742 @109 +@1750 := @1660 @95 +@1751 := @143 @1750 +@1754 := (h : @1655) -> (hs : @145) -> @1751 @112 +@1755 := @1749 @1653 +@1756 := @1658 @95 +@1758 := @143 @1756 @112 +@1759 := (hs : @145) -> @1758 +@1760 := @1755 @142 +@1762 := @143 @1657 @112 +@1763 := @221 @1648 +@1764 := @1638 @38 +@1765 := @29 @157 +@1766 := @96 @1765 +@1768 := @143 (@1766 @36) +@1774 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1764) -> (hs : @225) -> @1768 @171 +@1775 := @1763 @31 +@1780 := {vs : @147} -> {ts : @148} -> (h : @1643) -> (hs : @225) -> @1727 @260 +@1781 := @1775 @1657 +@1782 := @1751 @40 +@1783 := @1664 @1743 +@1788 := {ts : @148} -> (h : @1647) -> (hs : @1782) -> @143 @1783 @260 +@1789 := @1781 @112 +@1790 := @1662 @1750 +@1791 := @143 @1790 +@1794 := (h : @1651) -> (hs : @1758) -> @1791 @113 +@1795 := @1789 @1649 +@1796 := @1660 @1756 +@1798 := @143 @1796 @113 +@1799 := (hs : @1762) -> @1798 +@1800 := @1795 @1760 +@1802 := @143 @1659 @113 +@1803 := @221 @1644 +@1804 := @1634 @38 +@1805 := @29 @163 +@1806 := @96 @1805 +@1808 := @143 (@1806 @36) +@1814 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1804) -> (hs : @225) -> @1808 @171 +@1815 := @1803 @31 +@1820 := {vs : @147} -> {ts : @148} -> (h : @1639) -> (hs : @225) -> @1768 @260 +@1821 := @1815 @1659 +@1822 := @1791 @40 +@1823 := @1666 @1783 +@1828 := {ts : @148} -> (h : @1643) -> (hs : @1822) -> @143 @1823 @260 +@1829 := @1821 @113 +@1830 := @1664 @1790 +@1831 := @143 @1830 +@1834 := (h : @1647) -> (hs : @1798) -> @1831 @114 +@1835 := @1829 @1645 +@1836 := @1662 @1796 +@1838 := @143 @1836 @114 +@1839 := (hs : @1802) -> @1838 +@1840 := @1835 @1800 +@1842 := @143 @1661 @114 +@1843 := @221 @1640 +@1844 := @13 @1765 +@1845 := @1844 @38 +@1846 := #9 +@1847 := @29 @1846 +@1848 := @96 @1847 +@1850 := @143 (@1848 @36) +@1856 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1845) -> (hs : @225) -> @1850 @171 +@1857 := @1843 @31 +@1862 := {vs : @147} -> {ts : @148} -> (h : @1635) -> (hs : @225) -> @1808 @260 +@1863 := @1857 @1661 +@1864 := @1831 @40 +@1865 := @1766 @1823 +@1870 := {ts : @148} -> (h : @1639) -> (hs : @1864) -> @143 @1865 @260 +@1871 := @1863 @114 +@1872 := @1666 @1830 +@1873 := @143 @1872 +@1876 := (h : @1643) -> (hs : @1838) -> @1873 @115 +@1877 := @1871 @1641 +@1878 := @1664 @1836 +@1880 := @143 @1878 @115 +@1881 := (hs : @1842) -> @1880 +@1882 := @1877 @1840 +@1884 := @143 @1663 @115 +@1885 := @221 @1636 +@1886 := @13 @1805 +@1887 := @1886 @38 +@1888 := #10 +@1889 := @29 @1888 +@1890 := @96 @1889 +@1892 := @143 (@1890 @36) +@1898 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1887) -> (hs : @225) -> @1892 @171 +@1899 := @1885 @31 +@1900 := @1844 @31 +@1905 := {vs : @147} -> {ts : @148} -> (h : @1900) -> (hs : @225) -> @1850 @260 +@1906 := @1899 @1663 +@1907 := @1873 @40 +@1908 := @1806 @1865 +@1913 := {ts : @148} -> (h : @1635) -> (hs : @1907) -> @143 @1908 @260 +@1914 := @1906 @115 +@1915 := @1766 @1872 +@1916 := @143 @1915 +@1919 := (h : @1639) -> (hs : @1880) -> @1916 @116 +@1920 := @1914 @1637 +@1921 := @1666 @1878 +@1923 := @143 @1921 @116 +@1924 := (hs : @1884) -> @1923 +@1925 := @1920 @1882 +@1927 := @143 @1665 @116 +@1928 := @221 @1632 +@1930 := @13 @1847 @38 +@1931 := #11 +@1932 := @29 @1931 +@1933 := @96 @1932 +@1941 := {t : @92} -> + {vs : @147} -> {ts : @148} -> (h : @1930) -> (hs : @225) -> @143 (@1933 @36) @171 +@1942 := @1928 @31 +@1948 := {vs : @147} -> {ts : @148} -> (h : @1886 @31) -> (hs : @225) -> @1892 @260 +@1949 := @1942 @1665 +@1950 := @1916 @40 +@1951 := @1848 @1908 +@1952 := @143 @1951 +@1956 := {ts : @148} -> (h : @1900) -> (hs : @1950) -> @1952 @260 +@1957 := @1949 @116 +@1958 := @1806 @1915 +@1959 := @143 @1958 +@1962 := (h : @1635) -> (hs : @1923) -> @1959 @117 +@1963 := @1957 @1633 +@1964 := @1766 @1921 +@1965 := @143 @1964 +@1967 := (hs : @1927) -> @1965 @117 +@1968 := @1963 @1925 +@1969 := @143 @1667 +@1970 := @1969 @117 +@1971 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.denote +@1977 := @1971 @149 @151 @153 @36 @38 @40 +@1978 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.__fits_0 +@1984 := @1978 @149 @151 @153 @36 @38 @40 +@1992 := @29 (Reasoning.Main.triageLevel @149 @151 @153 @36 @38 @40) +@1999 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.root @149 @151 @153 @36 @38 @40 +@2000 := Bool +@2001 := Ne.{1} +@2002 := LexLeanPreservation.Obs +@2003 := @2001 @2002 +@2004 := LexLeanPreservation.Rel +@2007 := @2003 (@2004 @40 @4) +@2008 := LexLeanPreservation.Obs.stuck +@2011 := (f : @2000) -> (v : @91) -> @2007 @2008 +@2013 := LexLeanPreservation.Rust.rel_ne_stuck @1984 +@2024 := (v : @91) -> @2003 (@2004 (@1978 @157 @149 @151 @153 @36 @38) @4) @2008 +@2025 := @2013 @1992 +@2029 := @2003 (@2004 @1984 @1992) @2008 +@2030 := @146 @1670 +@2031 := LexLeanPreservation.Rust.FunSem +@2037 := (n : @35) -> @2031 @1846 @163 @157 @4 @149 +@2038 := @596 @1701 +@2039 := @595 @2038 +@2046 := LexLeanRuntime.index (@146 @1701) @1701 (LexLeanRuntime.instIndexableList @1701) +@2050 := @2039 (@2046 (@1702 @1846) @149) +@2051 := @604 @1701 +@2052 := @2051 @151 +@2053 := @2050 @2052 +@2057 := @118 @1888 @1846 @163 @151 +@2058 := LexLeanTarget.TargetSyntax.Function.types +@2059 := @2058 @149 +@2060 := @2057 @2059 +@2061 := @596 @2030 +@2062 := @595 @2061 +@2063 := LexLeanTarget.TargetSemantics.bindAll +@2064 := LexLeanTarget.TargetSyntax.Function.parameters +@2069 := @2062 (@2063 (@2064 @157) @149 @1686) +@2070 := @604 @2030 +@2071 := @2070 @151 +@2072 := @2069 @2071 +@2073 := @596 @2000 +@2074 := @595 @2073 +@2075 := LexLeanPreservation.Rust.fnFallible +@2078 := @2074 (@2075 @1931 @1846) +@2079 := @604 @2000 +@2080 := @2079 @151 +@2081 := @2078 @2080 +@2082 := LexLeanPreservation.RunConv +@2083 := #13 +@2087 := @2082 @2083 @1888 @163 @151 +@2089 := @2003 @149 @2008 +@2090 := Exists.{1} +@2091 := LexLeanPreservation.Rust.ROut +@2092 := @2090 @2091 +@2093 := And +@2094 := LexLeanPreservation.Rust.RealizesFn +@2098 := @2093 (@2094 @1846 @163 @4) +@2099 := LexLeanPreservation.Rust.RCI +@2100 := #15 +@2101 := @2099 @2100 +@2102 := LexLeanPreservation.Rust.fnIdent +@2103 := @2102 @2083 +@2110 := (hne : @2089) -> @2092 (fun (ro : @2091) => @2098 (@2101 @2103 @1931 @4)) +@2125 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2037) -> + (hfn : @2053) -> (hwt : @2060) -> (hbind : @2072) -> (hF : @2081) -> (hA : @2087) -> @2110 +@2127 := LexLeanPreservation.Rust.compose @0 +@2128 := @2031 @0 +@2133 := (n : @35) -> @2128 @163 @157 @4 @149 +@2134 := @2046 @1703 +@2137 := @2039 (@2134 @149) @2052 +@2141 := @129 @1846 @163 @151 @2059 +@2142 := @2082 @0 +@2145 := @2142 @1888 @163 @151 +@2159 := {c : @33} -> + {A : @34} -> + {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2133) -> + (hfn : @2137) -> (hwt : @2141) -> (hbind : @2072) -> (hF : @2081) -> (hA : @2145) -> @2110 +@2160 := @2127 @1 +@2161 := @2128 @1 +@2165 := (n : @35) -> @2161 @157 @4 @149 +@2168 := @137 @163 @151 @2059 +@2169 := @2075 @1 +@2172 := @2074 (@2169 @1846) @2080 +@2173 := @2099 @1 +@2183 := (hbind : @2072) -> + (hF : @2172) -> + (hA : @2145) -> (hne : @2089) -> @2092 (fun (ro : @2091) => @2098 (@2173 @2103 @1931 @4)) +@2193 := {A : @34} -> + {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> {o : @2002} -> (hB : @2165) -> (hfn : @2137) -> (hwt : @2168) -> @2183 +@2194 := @2160 @2 +@2196 := @2161 @2 @4 +@2198 := (n : @35) -> @2196 @149 +@2199 := @143 @151 +@2200 := @2199 @2059 +@2209 := {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> {o : @2002} -> (hB : @2198) -> (hfn : @2137) -> (hwt : @2200) -> @2183 +@2210 := @2194 @9 +@2212 := (n : @35) -> @2196 @9 +@2213 := @2134 @9 +@2214 := @2039 @2213 +@2215 := @2214 @2052 +@2216 := @2169 @9 +@2217 := @2074 @2216 +@2218 := @2217 @2080 +@2219 := @2142 @9 +@2221 := @2219 @163 @151 +@2223 := @2173 (@2102 @9) +@2231 := (hF : @2218) -> + (hA : @2221) -> (hne : @2089) -> @2092 (fun (ro : @2091) => @2098 (@2223 @1931 @4)) +@2240 := {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> (hB : @2212) -> (hfn : @2215) -> (hwt : @2200) -> (hbind : @2072) -> @2231 +@2241 := @2210 @1719 +@2243 := @2214 (@2051 @1719) +@2244 := @2058 @1719 +@2245 := @2199 @2244 +@2247 := @2063 (@2064 @1719) +@2259 := {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> (hwt : @2245) -> (hbind : @2062 (@2247 @149 @1686) @2071) -> @2231 +@2260 := @2241 @1667 +@2266 := @1933 (@1890 (@1848 (@1806 (@1766 (@1666 @95))))) +@2268 := @143 @2266 @2244 +@2269 := #12 +@2271 := @96 (@29 @2269) +@2277 := @2271 (@1933 (@1890 (@1848 (@1806 (@1766 @95))))) +@2281 := @2062 (@2247 @2277 @1686) @2071 +@2282 := #14 +@2284 := @96 (@29 @2282) +@2286 := @96 (@29 @2083) +@2292 := @2284 (@2286 (@2271 (@1933 (@1890 (@1848 @95))))) +@2294 := @2219 @2292 @151 +@2297 := @96 (@29 #17) +@2300 := @96 (@29 #16) +@2302 := @96 (@29 @2100) +@2323 := {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2268) -> + (hbind : @2281) -> + (hF : @2218) -> + (hA : @2294) -> + (hne : @2089) -> + @2092 (fun (ro : @2091) => @2098 (@2223 (@2297 (@2300 (@2302 (@2284 (@2286 (@2271 @95)))))) @4)) +@2324 := @2260 @1699 +@2330 := @1890 (@1848 (@1806 (@1766 (@1666 (@1664 @95))))) +@2332 := @143 @2330 @2244 +@2355 := @2062 + (@2247 @2266 @1686) + (@2070 + (@1687 + (@1674 @1632) + (@1687 + (@1676 @1765) + (@1687 + (@1678 @1805) + (@1687 (@1680 @1847) (@1687 (@1682 @1889) (@1687 (@1684 @1932) @1686))))))) +@2361 := @2286 (@2271 (@1933 (@1890 (@1848 (@1806 @95))))) +@2383 := {F : @2000} -> + {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2332) -> + (hbind : @2355) -> + (hF : @2218) -> + (hA : @2219 @2361 @151) -> + (hne : @2089) -> + @2092 (fun (ro : @2091) => @2098 (@2223 (@2300 (@2302 (@2284 (@2286 (@2271 (@1933 @95)))))) @4)) +@2384 := @2324 @1700 +@2385 := @1952 @2244 +@2408 := @2062 + (@2247 @2330 @1686) + (@2070 + (@1687 + (@1674 @1636) + (@1687 + (@1676 @1632) + (@1687 + (@1678 @1765) + (@1687 (@1680 @1805) (@1687 (@1682 @1847) (@1687 (@1684 @1889) @1686))))))) +@2410 := @2217 (@2079 @1700) +@2412 := @2219 @2277 @151 +@2413 := @2094 @1700 +@2435 := {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2385) -> + (hbind : @2408) -> + (hF : @2410) -> + (hA : @2412) -> + (hne : @2089) -> + @2092 + (fun (ro : @2091) => + @2093 (@2413 @163 @4) (@2223 (@2302 (@2284 (@2286 (@2271 (@1933 (@1890 @95)))))) @4)) +@2436 := @2384 @1977 +@2437 := @1959 @2244 +@2460 := @2062 + (@2247 @1951 @1686) + (@2070 + (@1687 + (@1674 @1640) + (@1687 + (@1676 @1636) + (@1687 + (@1678 @1632) + (@1687 (@1680 @1765) (@1687 (@1682 @1805) (@1687 (@1684 @1847) @1686))))))) +@2461 := @2219 @2266 +@2467 := @1971 @1931 @1888 @1846 @163 @157 @149 +@2468 := @2461 @2467 +@2474 := @1971 @2269 @1931 @1888 @1846 @163 @157 +@2497 := (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2437) -> + (hbind : @2460) -> + (hF : @2410) -> + (hA : @2468) -> + (hne : @2003 @2474 @2008) -> + @2092 + (fun (ro : @2091) => + @2093 (@2413 (@1971 @2282 @2083 @2269 @1931 @1888 @1846) @4) (@2223 @2292 @4)) +@2498 := @2436 @1723 +@2499 := @1965 @2244 +@2522 := @2062 + (@2247 @1958 @1686) + (@2070 + (@1687 + (@1674 @1644) + (@1687 + (@1676 @1640) + (@1687 + (@1678 @1636) + (@1687 (@1680 @1632) (@1687 (@1682 @1765) (@1687 (@1684 @1805) @1686))))))) +@2523 := @2219 @2330 +@2529 := @1971 @1888 @1846 @163 @157 @149 @151 +@2552 := (hfn : @2243) -> + (hwt : @2499) -> + (hbind : @2522) -> + (hF : @2410) -> + (hA : @2523 @2529) -> + (hne : @2003 @2467 @2008) -> + @2092 + (fun (ro : @2091) => + @2093 (@2413 (@1971 @2083 @2269 @1931 @1888 @1846 @163) @4) (@2223 @2361 @4)) +@2555 := @2498 (@704 @2038 @2213) +@2556 := @1969 @2244 +@2579 := @2062 + (@2247 @1964 @1686) + (@2070 + (@1687 + (@1674 @1648) + (@1687 + (@1676 @1644) + (@1687 + (@1678 @1640) + (@1687 (@1680 @1636) (@1687 (@1682 @1632) (@1687 (@1684 @1765) @1686))))))) +@2580 := @2219 @1951 +@2586 := @1971 @1846 @163 @157 @149 @151 @153 +@2602 := (hwt : @2556) -> + (hbind : @2579) -> + (hF : @2410) -> + (hA : @2580 @2586) -> + (hne : @2003 @2529 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2474 @4) (@2223 @2277 @4)) +@2603 := @2555 @1968 +@2605 := @2247 @1667 @1686 +@2608 := @2062 @2605 (@2070 @1699) +@2609 := @2219 @1958 +@2615 := @1971 @163 @157 @149 @151 @153 @36 +@2630 := (hbind : @2608) -> + (hF : @2410) -> + (hA : @2609 @2615) -> + (hne : @2003 @2586 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2467 @4) (@2223 @2266 @4)) +@2633 := @2603 (@704 @2061 @2605) +@2634 := @2219 @1964 +@2640 := @1971 @157 @149 @151 @153 @36 @38 +@2654 := (hF : @2410) -> + (hA : @2634 @2640) -> + (hne : @2003 @2615 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2529 @4) (@2223 @2330 @4)) +@2657 := @2633 (@704 @2073 @2216) +@2671 := (hA : @2219 @1667 @1977) -> + (hne : @2003 @2640 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2586 @4) (@2223 @1951 @4)) +@2672 := @2657 @1999 +@2683 := (hne : @2003 @1977 @2008) -> + @2092 (fun (ro : @2091) => @2093 (@2413 @2615 @4) (@2223 @1958 @4)) +@2684 := @2672 @2025 +@2690 := @2093 (@2413 @2640 @4) (@2223 @1964 @4) +@2692 := @2092 (fun (ro : @2091) => @2690) +@2694 := @2092 (fun (__e_ro : @2091) => @2690) +@2703 := LexLeanPreservation.Rust.RepresentableL + (@1664 (@1662 (@1660 (@1658 (@1656 (@96 @42 @95)))))) +@2704 := (__e_hrep : @2703) -> @2694 +@2705 := fun (__e_hrep : @2703) => @2684 +@2706 := (infection : @35) -> @2704 +@2707 := fun (infection : @35) => @2705 +@2708 := (systolic : @35) -> @2706 +@2709 := fun (systolic : @35) => @2707 +@2710 := (whiteCells : @35) -> @2708 +@2711 := fun (whiteCells : @35) => @2709 +@2712 := (respiratoryRate : @35) -> @2710 +@2713 := fun (respiratoryRate : @35) => @2711 +@2714 := (heartRate : @35) -> @2712 +@2715 := fun (heartRate : @35) => @2713 +@2716 := (temperature : @35) -> @2714 +@2717 := fun (temperature : @35) => @2715 +\end{coremodule} +\end{lexlean} diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R1/Compose/RustCore.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R1/Compose/RustCore.lean deleted file mode 100644 index daa0c4018..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R1/Compose/RustCore.lean +++ /dev/null @@ -1,32 +0,0 @@ -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1 -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore - -theorem __wt_0 : ∀ (__s : (Reasoning.Clinic.Vitals)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.__enc_0 __s) (.adt 0) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).temperature) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).heartRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).respiratoryRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).whiteCells) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).systolic) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).infection) _root_.LexLeanPreservation.Rust.wtl_nil)))))) - -theorem __wt_1 : ∀ (__s : (Reasoning.Clinic.Chart)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.__enc_1 __s) (.adt 1) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 (__s).vitals) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).fever) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).tachycardia) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).tachypnea) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).leukocytosis) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).sirs) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).sepsis) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).shock) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).level) _root_.LexLeanPreservation.Rust.wtl_nil))))))))) - -theorem __wt_2 : ∀ (__v : (Reasoning.Clinic.Triage.Step)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.__enc_2 __v) (.adt 2) - | Reasoning.Clinic.Triage.Step.Fever => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Tachycardia => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Tachypnea => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Leukocytosis => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Sirs => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Sepsis => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Shock => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Escalate => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteCells : Nat) (systolic : Nat) (infection : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.denote temperature heartRate respiratoryRate whiteCells systolic infection) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat temperature) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat heartRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat respiratoryRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat whiteCells) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat systolic) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat infection) _root_.LexLeanPreservation.Rust.wtl_nil)))))) rfl rfl (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.root temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R1/Compose/RustCore.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R1/Compose/RustCore.lex.tex new file mode 100644 index 000000000..1ce967565 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R1/Compose/RustCore.lex.tex @@ -0,0 +1,1341 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1, + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_1 : @724 := @1388 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_2 : @1396 := @1631 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.root : @2716 := @2717 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.program +@1 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.krate +@2 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.flags +@3 := Reasoning.Clinic.Vitals +@4 := #0 +@5 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@16 := (__s : @3) -> @13 @6 @10 +@17 := Reasoning.Clinic.Vitals.temperature +@18 := @17 @4 +@19 := Reasoning.Clinic.Vitals.heartRate +@20 := @19 @4 +@21 := Reasoning.Clinic.Vitals.respiratoryRate +@22 := @21 @4 +@23 := Reasoning.Clinic.Vitals.whiteCells +@24 := @23 @4 +@25 := Reasoning.Clinic.Vitals.systolic +@26 := @25 @4 +@27 := Reasoning.Clinic.Vitals.infection +@28 := @27 @4 +@29 := LexLeanTarget.TargetSyntax.Value.nat +@30 := @29 @18 +@31 := LexLeanTarget.TargetSyntax.Ty.nat +@32 := LexLeanTarget.TargetSyntax.Program +@33 := LexLeanPreservation.Rust.RCrate +@34 := LexLeanPreservation.Rust.Flags +@35 := Nat +@36 := #3 +@37 := @7 @36 +@38 := #2 +@39 := @37 @38 +@40 := #1 +@41 := @39 @40 +@42 := @29 @4 +@48 := {p : @32} -> {c : @33} -> {A : @34} -> (n : @35) -> @41 @42 @31 +@50 := LexLeanPreservation.Rust.wt_nat @0 +@57 := {c : @33} -> {A : @34} -> (n : @35) -> @11 @38 @40 @42 @31 +@58 := @50 @1 +@63 := {A : @34} -> (n : @35) -> @12 @40 @42 @31 +@64 := @58 @2 +@67 := (n : @35) -> @13 @42 @31 +@68 := @64 @18 +@70 := @13 @30 @31 +@71 := @29 @20 +@72 := @64 @20 +@74 := @13 @71 @31 +@75 := @29 @22 +@76 := @64 @22 +@78 := @13 @75 @31 +@79 := @29 @24 +@80 := @64 @24 +@82 := @13 @79 @31 +@83 := @29 @26 +@84 := @64 @26 +@86 := @13 @83 @31 +@87 := @29 @28 +@88 := @64 @28 +@90 := @13 @87 @31 +@91 := LexLeanTarget.TargetSyntax.Value +@92 := LexLeanTarget.TargetSyntax.Ty +@93 := List.nil.{0} +@94 := List.cons.{0} +@95 := @93 @91 +@96 := @94 @91 +@98 := @96 @87 @95 +@100 := @96 @83 @98 +@102 := @96 @79 @100 +@104 := @96 @75 @102 +@106 := @96 @71 @104 +@108 := @96 @30 @106 +@109 := @93 @92 +@110 := @94 @92 +@111 := @110 @31 +@112 := @111 @109 +@113 := @111 @112 +@114 := @111 @113 +@115 := @111 @114 +@116 := @111 @115 +@117 := @111 @116 +@118 := LexLeanPreservation.Rust.WTL +@126 := {p : @32} -> {c : @33} -> {A : @34} -> @118 @38 @40 @4 @95 @109 +@128 := LexLeanPreservation.Rust.wtl_nil @0 +@129 := @118 @0 +@135 := {c : @33} -> {A : @34} -> @129 @40 @4 @95 @109 +@136 := @128 @1 +@137 := @129 @1 +@141 := {A : @34} -> @137 @4 @95 @109 +@142 := @136 @2 +@143 := @137 @2 +@144 := @143 @95 +@145 := @144 @109 +@146 := List.{0} +@147 := @146 @91 +@148 := @146 @92 +@149 := #6 +@150 := @7 @149 +@151 := #5 +@152 := @150 @151 +@153 := #4 +@156 := @152 @153 @36 @38 +@157 := #7 +@162 := @118 @157 @149 @151 @38 @40 +@163 := #8 +@166 := @118 @163 @157 @149 +@168 := @96 @151 @36 +@169 := @166 @168 +@171 := @110 @153 @38 +@181 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {v : @91} -> {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @156) -> (hs : @162) -> @169 @171 +@183 := LexLeanPreservation.Rust.wtl_cons @0 +@187 := @11 @151 @153 @36 @38 +@191 := @129 @149 @151 @38 @40 +@203 := {c : @33} -> + {A : @34} -> + {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @187) -> (hs : @191) -> @129 @157 @149 @168 @171 +@204 := @183 @1 +@207 := @12 @153 @36 @38 +@210 := @137 @151 @38 @40 +@220 := {A : @34} -> + {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @207) -> (hs : @210) -> @137 @149 @168 @171 +@221 := @204 @2 +@223 := @13 @36 @38 +@225 := @143 @38 @40 +@233 := {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @223) -> (hs : @225) -> @143 @168 @171 +@234 := @221 @87 +@236 := @29 (@27 @36) +@249 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @236 @38) -> (hs : @225) -> @143 (@96 (@29 (@27 @151)) @36) @171 +@250 := @234 @31 +@252 := @29 (@27 @38) +@254 := @13 @252 @31 +@259 := @143 (@96 (@29 (@27 @153)) @36) +@260 := @111 @38 +@265 := {vs : @147} -> {ts : @148} -> (h : @254) -> (hs : @225) -> @259 @260 +@266 := @250 @95 +@268 := @29 (@27 @40) +@270 := @13 @268 @31 +@271 := @144 @40 +@273 := @96 @236 @95 +@278 := {ts : @148} -> (h : @270) -> (hs : @271) -> @143 @273 @260 +@279 := @266 @109 +@281 := @96 @252 @95 +@282 := @143 @281 +@285 := (h : @90) -> (hs : @145) -> @282 @112 +@286 := @279 @88 +@288 := @96 @268 @95 +@290 := @143 @288 @112 +@291 := (hs : @145) -> @290 +@292 := @286 @142 +@294 := @143 @98 @112 +@295 := @221 @83 +@297 := @29 (@25 @36) +@310 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @297 @38) -> (hs : @225) -> @143 (@96 (@29 (@25 @151)) @36) @171 +@311 := @295 @31 +@313 := @29 (@25 @38) +@325 := {vs : @147} -> + {ts : @148} -> (h : @13 @313 @31) -> (hs : @225) -> @143 (@96 (@29 (@25 @153)) @36) @260 +@326 := @311 @98 +@328 := @29 (@25 @40) +@330 := @13 @328 @31 +@331 := @282 @40 +@333 := @96 @297 @273 +@338 := {ts : @148} -> (h : @330) -> (hs : @331) -> @143 @333 @260 +@339 := @326 @112 +@341 := @96 @313 @281 +@342 := @143 @341 +@345 := (h : @86) -> (hs : @290) -> @342 @113 +@346 := @339 @84 +@348 := @96 @328 @288 +@350 := @143 @348 @113 +@351 := (hs : @294) -> @350 +@352 := @346 @292 +@354 := @143 @100 @113 +@355 := @221 @79 +@357 := @29 (@23 @36) +@370 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @357 @38) -> (hs : @225) -> @143 (@96 (@29 (@23 @151)) @36) @171 +@371 := @355 @31 +@373 := @29 (@23 @38) +@385 := {vs : @147} -> + {ts : @148} -> (h : @13 @373 @31) -> (hs : @225) -> @143 (@96 (@29 (@23 @153)) @36) @260 +@386 := @371 @100 +@388 := @29 (@23 @40) +@390 := @13 @388 @31 +@391 := @342 @40 +@393 := @96 @357 @333 +@398 := {ts : @148} -> (h : @390) -> (hs : @391) -> @143 @393 @260 +@399 := @386 @113 +@401 := @96 @373 @341 +@402 := @143 @401 +@405 := (h : @82) -> (hs : @350) -> @402 @114 +@406 := @399 @80 +@408 := @96 @388 @348 +@410 := @143 @408 @114 +@411 := (hs : @354) -> @410 +@412 := @406 @352 +@414 := @143 @102 @114 +@415 := @221 @75 +@417 := @29 (@21 @36) +@430 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @417 @38) -> (hs : @225) -> @143 (@96 (@29 (@21 @151)) @36) @171 +@431 := @415 @31 +@433 := @29 (@21 @38) +@445 := {vs : @147} -> + {ts : @148} -> (h : @13 @433 @31) -> (hs : @225) -> @143 (@96 (@29 (@21 @153)) @36) @260 +@446 := @431 @102 +@448 := @29 (@21 @40) +@450 := @13 @448 @31 +@451 := @402 @40 +@453 := @96 @417 @393 +@458 := {ts : @148} -> (h : @450) -> (hs : @451) -> @143 @453 @260 +@459 := @446 @114 +@461 := @96 @433 @401 +@462 := @143 @461 +@465 := (h : @78) -> (hs : @410) -> @462 @115 +@466 := @459 @76 +@468 := @96 @448 @408 +@470 := @143 @468 @115 +@471 := (hs : @414) -> @470 +@472 := @466 @412 +@474 := @143 @104 @115 +@475 := @221 @71 +@477 := @29 (@19 @36) +@490 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @477 @38) -> (hs : @225) -> @143 (@96 (@29 (@19 @151)) @36) @171 +@491 := @475 @31 +@493 := @29 (@19 @38) +@505 := {vs : @147} -> + {ts : @148} -> (h : @13 @493 @31) -> (hs : @225) -> @143 (@96 (@29 (@19 @153)) @36) @260 +@506 := @491 @104 +@508 := @29 (@19 @40) +@510 := @13 @508 @31 +@511 := @462 @40 +@513 := @96 @477 @453 +@518 := {ts : @148} -> (h : @510) -> (hs : @511) -> @143 @513 @260 +@519 := @506 @115 +@521 := @96 @493 @461 +@522 := @143 @521 +@525 := (h : @74) -> (hs : @470) -> @522 @116 +@526 := @519 @72 +@528 := @96 @508 @468 +@530 := @143 @528 @116 +@531 := (hs : @474) -> @530 +@532 := @526 @472 +@534 := @143 @106 @116 +@535 := @221 @30 +@537 := @29 (@17 @36) +@550 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @537 @38) -> (hs : @225) -> @143 (@96 (@29 (@17 @151)) @36) @171 +@551 := @535 @31 +@553 := @29 (@17 @38) +@565 := {vs : @147} -> + {ts : @148} -> (h : @13 @553 @31) -> (hs : @225) -> @143 (@96 (@29 (@17 @153)) @36) @260 +@566 := @551 @106 +@568 := @29 (@17 @40) +@570 := @13 @568 @31 +@571 := @522 @40 +@573 := @96 @537 @513 +@578 := {ts : @148} -> (h : @570) -> (hs : @571) -> @143 @573 @260 +@579 := @566 @116 +@581 := @96 @553 @521 +@582 := @143 @581 +@585 := (h : @70) -> (hs : @530) -> @582 @117 +@586 := @579 @68 +@588 := @96 @568 @528 +@590 := @143 @588 @117 +@591 := (hs : @534) -> @590 +@592 := @586 @532 +@594 := @143 @108 @117 +@595 := Eq.{1} +@596 := Option.{0} +@597 := @596 @148 +@598 := @595 @597 +@599 := LexLeanPreservation.Rust.adtFields +@603 := @598 (@599 @149 @36 @38) +@604 := Option.some.{0} +@605 := @604 @148 +@606 := @605 @4 +@607 := @603 @606 +@610 := @7 @163 @157 @149 +@611 := LexLeanTarget.TargetSyntax.Value.adt +@613 := @611 @153 @36 +@614 := @610 @613 +@615 := @8 @151 +@625 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {i : @35} -> {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @607) -> (hf : @162) -> @614 @615 +@627 := LexLeanPreservation.Rust.wt_adt @0 +@628 := @599 @0 +@632 := @598 (@628 @36 @38) @606 +@644 := {c : @33} -> + {A : @34} -> + {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @191) -> @11 @157 @149 @613 @615 +@645 := @627 @1 +@655 := {A : @34} -> + {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @210) -> @12 @149 @613 @615 +@656 := @645 @2 +@657 := @13 @613 +@664 := {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @225) -> @657 @615 +@665 := @656 @9 +@666 := @628 @9 +@675 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@666 @38) @606) -> (hf : @225) -> @657 @10 +@676 := @665 @9 +@677 := @666 @9 +@678 := @598 @677 +@679 := @678 @606 +@680 := @611 @9 +@682 := @13 (@680 @36) +@687 := {fs : @147} -> {tys : @148} -> (h : @679) -> (hf : @225) -> @682 @10 +@688 := @676 @108 +@695 := {tys : @148} -> (h : @679) -> (hf : @582 @40) -> @13 (@680 @573) @10 +@696 := @688 @117 +@703 := (h : @678 (@605 @117)) -> (hf : @590) -> @13 (@680 @581) @10 +@704 := Eq.refl.{1} +@705 := @704 @597 +@707 := @696 (@705 @677) +@711 := (hf : @594) -> @13 (@680 @588) @10 +@712 := @707 @592 +@715 := @13 (@680 @108) @10 +@716 := fun (__s : @3) => @712 +@717 := Reasoning.Clinic.Chart +@719 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.__enc_1 @4 +@720 := 1 +@721 := @8 @720 +@724 := (__s : @717) -> @13 @719 @721 +@725 := Reasoning.Clinic.Chart.vitals +@726 := @725 @4 +@727 := Reasoning.Clinic.Chart.fever +@728 := @727 @4 +@729 := Reasoning.Clinic.Chart.tachycardia +@730 := @729 @4 +@731 := Reasoning.Clinic.Chart.tachypnea +@732 := @731 @4 +@733 := Reasoning.Clinic.Chart.leukocytosis +@734 := @733 @4 +@735 := Reasoning.Clinic.Chart.sirs +@736 := @735 @4 +@737 := Reasoning.Clinic.Chart.sepsis +@738 := @737 @4 +@739 := Reasoning.Clinic.Chart.shock +@740 := @739 @4 +@741 := Reasoning.Clinic.Chart.level +@742 := @741 @4 +@743 := @5 @726 +@745 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_0 @726 +@746 := @29 @728 +@747 := @64 @728 +@749 := @13 @746 @31 +@750 := @29 @730 +@751 := @64 @730 +@753 := @13 @750 @31 +@754 := @29 @732 +@755 := @64 @732 +@757 := @13 @754 @31 +@758 := @29 @734 +@759 := @64 @734 +@761 := @13 @758 @31 +@762 := @29 @736 +@763 := @64 @736 +@765 := @13 @762 @31 +@766 := @29 @738 +@767 := @64 @738 +@769 := @13 @766 @31 +@770 := @29 @740 +@771 := @64 @740 +@773 := @13 @770 @31 +@774 := @29 @742 +@775 := @64 @742 +@777 := @13 @774 @31 +@779 := @96 @774 @95 +@781 := @96 @770 @779 +@783 := @96 @766 @781 +@785 := @96 @762 @783 +@787 := @96 @758 @785 +@789 := @96 @754 @787 +@791 := @96 @750 @789 +@793 := @96 @746 @791 +@795 := @96 @743 @793 +@796 := @111 @117 +@797 := @111 @796 +@798 := @110 @10 +@799 := @798 @797 +@800 := @221 @774 +@802 := @29 (@741 @36) +@815 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @802 @38) -> (hs : @225) -> @143 (@96 (@29 (@741 @151)) @36) @171 +@816 := @800 @31 +@818 := @29 (@741 @38) +@830 := {vs : @147} -> + {ts : @148} -> (h : @13 @818 @31) -> (hs : @225) -> @143 (@96 (@29 (@741 @153)) @36) @260 +@831 := @816 @95 +@833 := @29 (@741 @40) +@835 := @13 @833 @31 +@837 := @96 @802 @95 +@842 := {ts : @148} -> (h : @835) -> (hs : @271) -> @143 @837 @260 +@843 := @831 @109 +@845 := @96 @818 @95 +@846 := @143 @845 +@849 := (h : @777) -> (hs : @145) -> @846 @112 +@850 := @843 @775 +@852 := @96 @833 @95 +@854 := @143 @852 @112 +@855 := (hs : @145) -> @854 +@856 := @850 @142 +@858 := @143 @779 @112 +@859 := @221 @770 +@861 := @29 (@739 @36) +@874 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @861 @38) -> (hs : @225) -> @143 (@96 (@29 (@739 @151)) @36) @171 +@875 := @859 @31 +@877 := @29 (@739 @38) +@889 := {vs : @147} -> + {ts : @148} -> (h : @13 @877 @31) -> (hs : @225) -> @143 (@96 (@29 (@739 @153)) @36) @260 +@890 := @875 @779 +@892 := @29 (@739 @40) +@894 := @13 @892 @31 +@895 := @846 @40 +@897 := @96 @861 @837 +@902 := {ts : @148} -> (h : @894) -> (hs : @895) -> @143 @897 @260 +@903 := @890 @112 +@905 := @96 @877 @845 +@906 := @143 @905 +@909 := (h : @773) -> (hs : @854) -> @906 @113 +@910 := @903 @771 +@912 := @96 @892 @852 +@914 := @143 @912 @113 +@915 := (hs : @858) -> @914 +@916 := @910 @856 +@918 := @143 @781 @113 +@919 := @221 @766 +@921 := @29 (@737 @36) +@934 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @921 @38) -> (hs : @225) -> @143 (@96 (@29 (@737 @151)) @36) @171 +@935 := @919 @31 +@937 := @29 (@737 @38) +@949 := {vs : @147} -> + {ts : @148} -> (h : @13 @937 @31) -> (hs : @225) -> @143 (@96 (@29 (@737 @153)) @36) @260 +@950 := @935 @781 +@952 := @29 (@737 @40) +@954 := @13 @952 @31 +@955 := @906 @40 +@957 := @96 @921 @897 +@962 := {ts : @148} -> (h : @954) -> (hs : @955) -> @143 @957 @260 +@963 := @950 @113 +@965 := @96 @937 @905 +@966 := @143 @965 +@969 := (h : @769) -> (hs : @914) -> @966 @114 +@970 := @963 @767 +@972 := @96 @952 @912 +@974 := @143 @972 @114 +@975 := (hs : @918) -> @974 +@976 := @970 @916 +@978 := @143 @783 @114 +@979 := @221 @762 +@981 := @29 (@735 @36) +@994 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @981 @38) -> (hs : @225) -> @143 (@96 (@29 (@735 @151)) @36) @171 +@995 := @979 @31 +@997 := @29 (@735 @38) +@1009 := {vs : @147} -> + {ts : @148} -> (h : @13 @997 @31) -> (hs : @225) -> @143 (@96 (@29 (@735 @153)) @36) @260 +@1010 := @995 @783 +@1012 := @29 (@735 @40) +@1014 := @13 @1012 @31 +@1015 := @966 @40 +@1017 := @96 @981 @957 +@1022 := {ts : @148} -> (h : @1014) -> (hs : @1015) -> @143 @1017 @260 +@1023 := @1010 @114 +@1025 := @96 @997 @965 +@1026 := @143 @1025 +@1029 := (h : @765) -> (hs : @974) -> @1026 @115 +@1030 := @1023 @763 +@1032 := @96 @1012 @972 +@1034 := @143 @1032 @115 +@1035 := (hs : @978) -> @1034 +@1036 := @1030 @976 +@1038 := @143 @785 @115 +@1039 := @221 @758 +@1041 := @29 (@733 @36) +@1054 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1041 @38) -> (hs : @225) -> @143 (@96 (@29 (@733 @151)) @36) @171 +@1055 := @1039 @31 +@1057 := @29 (@733 @38) +@1069 := {vs : @147} -> + {ts : @148} -> (h : @13 @1057 @31) -> (hs : @225) -> @143 (@96 (@29 (@733 @153)) @36) @260 +@1070 := @1055 @785 +@1072 := @29 (@733 @40) +@1074 := @13 @1072 @31 +@1075 := @1026 @40 +@1077 := @96 @1041 @1017 +@1082 := {ts : @148} -> (h : @1074) -> (hs : @1075) -> @143 @1077 @260 +@1083 := @1070 @115 +@1085 := @96 @1057 @1025 +@1086 := @143 @1085 +@1089 := (h : @761) -> (hs : @1034) -> @1086 @116 +@1090 := @1083 @759 +@1092 := @96 @1072 @1032 +@1094 := @143 @1092 @116 +@1095 := (hs : @1038) -> @1094 +@1096 := @1090 @1036 +@1098 := @143 @787 @116 +@1099 := @221 @754 +@1101 := @29 (@731 @36) +@1114 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1101 @38) -> (hs : @225) -> @143 (@96 (@29 (@731 @151)) @36) @171 +@1115 := @1099 @31 +@1117 := @29 (@731 @38) +@1129 := {vs : @147} -> + {ts : @148} -> (h : @13 @1117 @31) -> (hs : @225) -> @143 (@96 (@29 (@731 @153)) @36) @260 +@1130 := @1115 @787 +@1132 := @29 (@731 @40) +@1134 := @13 @1132 @31 +@1135 := @1086 @40 +@1137 := @96 @1101 @1077 +@1142 := {ts : @148} -> (h : @1134) -> (hs : @1135) -> @143 @1137 @260 +@1143 := @1130 @116 +@1145 := @96 @1117 @1085 +@1146 := @143 @1145 +@1149 := (h : @757) -> (hs : @1094) -> @1146 @117 +@1150 := @1143 @755 +@1152 := @96 @1132 @1092 +@1154 := @143 @1152 @117 +@1155 := (hs : @1098) -> @1154 +@1156 := @1150 @1096 +@1158 := @143 @789 @117 +@1159 := @221 @750 +@1161 := @29 (@729 @36) +@1174 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1161 @38) -> (hs : @225) -> @143 (@96 (@29 (@729 @151)) @36) @171 +@1175 := @1159 @31 +@1177 := @29 (@729 @38) +@1189 := {vs : @147} -> + {ts : @148} -> (h : @13 @1177 @31) -> (hs : @225) -> @143 (@96 (@29 (@729 @153)) @36) @260 +@1190 := @1175 @789 +@1192 := @29 (@729 @40) +@1194 := @13 @1192 @31 +@1195 := @1146 @40 +@1197 := @96 @1161 @1137 +@1202 := {ts : @148} -> (h : @1194) -> (hs : @1195) -> @143 @1197 @260 +@1203 := @1190 @117 +@1205 := @96 @1177 @1145 +@1206 := @143 @1205 +@1209 := (h : @753) -> (hs : @1154) -> @1206 @796 +@1210 := @1203 @751 +@1212 := @96 @1192 @1152 +@1214 := @143 @1212 @796 +@1215 := (hs : @1158) -> @1214 +@1216 := @1210 @1156 +@1218 := @143 @791 @796 +@1219 := @221 @746 +@1221 := @29 (@727 @36) +@1234 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1221 @38) -> (hs : @225) -> @143 (@96 (@29 (@727 @151)) @36) @171 +@1235 := @1219 @31 +@1237 := @29 (@727 @38) +@1249 := {vs : @147} -> + {ts : @148} -> (h : @13 @1237 @31) -> (hs : @225) -> @143 (@96 (@29 (@727 @153)) @36) @260 +@1250 := @1235 @791 +@1252 := @29 (@727 @40) +@1254 := @13 @1252 @31 +@1255 := @1206 @40 +@1257 := @96 @1221 @1197 +@1262 := {ts : @148} -> (h : @1254) -> (hs : @1255) -> @143 @1257 @260 +@1263 := @1250 @796 +@1265 := @96 @1237 @1205 +@1266 := @143 @1265 +@1269 := (h : @749) -> (hs : @1214) -> @1266 @797 +@1270 := @1263 @747 +@1272 := @96 @1252 @1212 +@1274 := @143 @1272 @797 +@1275 := (hs : @1218) -> @1274 +@1276 := @1270 @1216 +@1278 := @143 @793 @797 +@1279 := @221 @743 +@1281 := @5 (@725 @36) +@1294 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1281 @38) -> (hs : @225) -> @143 (@96 (@5 (@725 @151)) @36) @171 +@1295 := @1279 @10 +@1297 := @5 (@725 @38) +@1299 := @13 @1297 @10 +@1304 := @143 (@96 (@5 (@725 @153)) @36) +@1305 := @798 @38 +@1310 := {vs : @147} -> {ts : @148} -> (h : @1299) -> (hs : @225) -> @1304 @1305 +@1311 := @1295 @793 +@1313 := @5 (@725 @40) +@1315 := @13 @1313 @10 +@1316 := @1266 @40 +@1318 := @96 @1281 @1257 +@1323 := {ts : @148} -> (h : @1315) -> (hs : @1316) -> @143 @1318 @1305 +@1324 := @1311 @797 +@1326 := @13 @743 @10 +@1328 := @96 @1297 @1265 +@1329 := @143 @1328 +@1332 := (h : @1326) -> (hs : @1274) -> @1329 @799 +@1333 := @1324 @745 +@1335 := @96 @1313 @1272 +@1337 := @143 @1335 @799 +@1338 := (hs : @1278) -> @1337 +@1339 := @1333 @1276 +@1341 := @143 @795 @799 +@1342 := @656 @720 +@1343 := @628 @720 +@1352 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@1343 @38) @606) -> (hf : @225) -> @657 @721 +@1353 := @1342 @9 +@1354 := @1343 @9 +@1355 := @598 @1354 +@1356 := @1355 @606 +@1361 := {fs : @147} -> {tys : @148} -> (h : @1356) -> (hf : @225) -> @682 @721 +@1362 := @1353 @795 +@1369 := {tys : @148} -> (h : @1356) -> (hf : @1329 @40) -> @13 (@680 @1318) @721 +@1370 := @1362 @799 +@1377 := (h : @1355 (@605 @799)) -> (hf : @1337) -> @13 (@680 @1328) @721 +@1379 := @1370 (@705 @1354) +@1383 := (hf : @1341) -> @13 (@680 @1335) @721 +@1384 := @1379 @1339 +@1387 := @13 (@680 @795) @721 +@1388 := fun (__s : @717) => @1384 +@1389 := Reasoning.Clinic.Triage.Step +@1391 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.__enc_2 @4 +@1392 := 2 +@1393 := @8 @1392 +@1395 := @13 @1391 @1393 +@1396 := (__v : @1389) -> @1395 +@1397 := fun (__v : @1389) => @1395 +@1398 := @656 @1392 +@1399 := @628 @1392 +@1408 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@1399 @38) @606) -> (hf : @225) -> @657 @1393 +@1409 := @1398 @9 +@1410 := @1399 @9 +@1411 := @598 @1410 +@1412 := @1411 @606 +@1417 := {fs : @147} -> {tys : @148} -> (h : @1412) -> (hf : @225) -> @682 @1393 +@1418 := @1409 @95 +@1421 := @13 (@680 @95) @1393 +@1424 := {tys : @148} -> (h : @1412) -> (hf : @271) -> @1421 +@1425 := @1418 @109 +@1426 := @605 @109 +@1429 := (h : @1411 @1426) -> (hf : @145) -> @1421 +@1432 := @1425 (@705 @1410) @142 +@1433 := @1398 @720 +@1434 := @1399 @720 +@1435 := @598 @1434 +@1436 := @1435 @606 +@1437 := @611 @720 +@1444 := {fs : @147} -> {tys : @148} -> (h : @1436) -> (hf : @225) -> @13 (@1437 @36) @1393 +@1445 := @1433 @95 +@1448 := @13 (@1437 @95) @1393 +@1451 := {tys : @148} -> (h : @1436) -> (hf : @271) -> @1448 +@1452 := @1445 @109 +@1455 := (h : @1435 @1426) -> (hf : @145) -> @1448 +@1458 := @1452 (@705 @1434) @142 +@1459 := @1398 @1392 +@1460 := @1399 @1392 +@1461 := @598 @1460 +@1462 := @1461 @606 +@1463 := @611 @1392 +@1470 := {fs : @147} -> {tys : @148} -> (h : @1462) -> (hf : @225) -> @13 (@1463 @36) @1393 +@1471 := @1459 @95 +@1474 := @13 (@1463 @95) @1393 +@1477 := {tys : @148} -> (h : @1462) -> (hf : @271) -> @1474 +@1478 := @1471 @109 +@1481 := (h : @1461 @1426) -> (hf : @145) -> @1474 +@1484 := @1478 (@705 @1460) @142 +@1485 := 3 +@1486 := @1398 @1485 +@1487 := @1399 @1485 +@1488 := @598 @1487 +@1489 := @1488 @606 +@1490 := @611 @1485 +@1497 := {fs : @147} -> {tys : @148} -> (h : @1489) -> (hf : @225) -> @13 (@1490 @36) @1393 +@1498 := @1486 @95 +@1501 := @13 (@1490 @95) @1393 +@1504 := {tys : @148} -> (h : @1489) -> (hf : @271) -> @1501 +@1505 := @1498 @109 +@1508 := (h : @1488 @1426) -> (hf : @145) -> @1501 +@1511 := @1505 (@705 @1487) @142 +@1512 := 4 +@1513 := @1398 @1512 +@1514 := @1399 @1512 +@1515 := @598 @1514 +@1516 := @1515 @606 +@1517 := @611 @1512 +@1524 := {fs : @147} -> {tys : @148} -> (h : @1516) -> (hf : @225) -> @13 (@1517 @36) @1393 +@1525 := @1513 @95 +@1528 := @13 (@1517 @95) @1393 +@1531 := {tys : @148} -> (h : @1516) -> (hf : @271) -> @1528 +@1532 := @1525 @109 +@1535 := (h : @1515 @1426) -> (hf : @145) -> @1528 +@1538 := @1532 (@705 @1514) @142 +@1539 := 5 +@1540 := @1398 @1539 +@1541 := @1399 @1539 +@1542 := @598 @1541 +@1543 := @1542 @606 +@1544 := @611 @1539 +@1551 := {fs : @147} -> {tys : @148} -> (h : @1543) -> (hf : @225) -> @13 (@1544 @36) @1393 +@1552 := @1540 @95 +@1555 := @13 (@1544 @95) @1393 +@1558 := {tys : @148} -> (h : @1543) -> (hf : @271) -> @1555 +@1559 := @1552 @109 +@1562 := (h : @1542 @1426) -> (hf : @145) -> @1555 +@1565 := @1559 (@705 @1541) @142 +@1566 := 6 +@1567 := @1398 @1566 +@1568 := @1399 @1566 +@1569 := @598 @1568 +@1570 := @1569 @606 +@1571 := @611 @1566 +@1578 := {fs : @147} -> {tys : @148} -> (h : @1570) -> (hf : @225) -> @13 (@1571 @36) @1393 +@1579 := @1567 @95 +@1582 := @13 (@1571 @95) @1393 +@1585 := {tys : @148} -> (h : @1570) -> (hf : @271) -> @1582 +@1586 := @1579 @109 +@1589 := (h : @1569 @1426) -> (hf : @145) -> @1582 +@1592 := @1586 (@705 @1568) @142 +@1593 := 7 +@1594 := @1398 @1593 +@1595 := @1399 @1593 +@1596 := @598 @1595 +@1597 := @1596 @606 +@1598 := @611 @1593 +@1605 := {fs : @147} -> {tys : @148} -> (h : @1597) -> (hf : @225) -> @13 (@1598 @36) @1393 +@1606 := @1594 @95 +@1609 := @13 (@1598 @95) @1393 +@1612 := {tys : @148} -> (h : @1597) -> (hf : @271) -> @1609 +@1613 := @1606 @109 +@1616 := (h : @1596 @1426) -> (hf : @145) -> @1609 +@1619 := @1613 (@705 @1595) @142 +@1631 := fun (__v : @1389) => + Reasoning.Clinic.Triage.Step.casesOn.{0} @1397 @4 @1432 @1458 @1484 @1511 @1538 @1565 @1592 @1619 +@1632 := @29 @149 +@1633 := @64 @149 +@1634 := @13 @1632 +@1635 := @1634 @31 +@1636 := @29 @151 +@1637 := @64 @151 +@1638 := @13 @1636 +@1639 := @1638 @31 +@1640 := @29 @153 +@1641 := @64 @153 +@1642 := @13 @1640 +@1643 := @1642 @31 +@1644 := @29 @36 +@1645 := @64 @36 +@1647 := @13 @1644 @31 +@1648 := @29 @38 +@1649 := @64 @38 +@1651 := @13 @1648 @31 +@1652 := @29 @40 +@1653 := @64 @40 +@1655 := @13 @1652 @31 +@1656 := @96 @1652 +@1657 := @1656 @95 +@1658 := @96 @1648 +@1659 := @1658 @1657 +@1660 := @96 @1644 +@1661 := @1660 @1659 +@1662 := @96 @1640 +@1663 := @1662 @1661 +@1664 := @96 @1636 +@1665 := @1664 @1663 +@1666 := @96 @1632 +@1667 := @1666 @1665 +@1670 := Prod.{0, 0} @35 @91 +@1673 := Prod.mk.{0, 0} @35 @91 +@1674 := @1673 @1539 +@1675 := @1674 @1652 +@1676 := @1673 @1512 +@1677 := @1676 @1648 +@1678 := @1673 @1485 +@1679 := @1678 @1644 +@1680 := @1673 @1392 +@1681 := @1680 @1640 +@1682 := @1673 @720 +@1683 := @1682 @1636 +@1684 := @1673 @9 +@1685 := @1684 @1632 +@1686 := @93 @1670 +@1687 := @94 @1670 +@1689 := @1687 @1685 @1686 +@1691 := @1687 @1683 @1689 +@1693 := @1687 @1681 @1691 +@1695 := @1687 @1679 @1693 +@1697 := @1687 @1677 @1695 +@1699 := @1687 @1675 @1697 +@1700 := Bool.true +@1701 := LexLeanTarget.TargetSyntax.Function +@1702 := LexLeanTarget.TargetSyntax.Program.functions +@1703 := @1702 @0 +@1704 := @93 @35 +@1705 := LexLeanTarget.TargetSyntax.Ty.unit +@1706 := LexLeanTarget.TargetSyntax.Value.unit +@1709 := LexLeanTarget.TargetSyntax.Expr.value @1705 @1706 +@1714 := LexLeanTarget.TargetSyntax.Function.mk @1704 @109 @1705 @1709 +@1719 := List.getD.{0} @1701 @1703 @9 @1714 +@1723 := fun (__e_n : @35) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.root @4 @9 +@1724 := @221 @1652 +@1725 := @1642 @38 +@1727 := @143 (@1666 @36) +@1733 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1725) -> (hs : @225) -> @1727 @171 +@1734 := @1724 @31 +@1741 := {vs : @147} -> {ts : @148} -> (h : @1647) -> (hs : @225) -> @143 (@1664 @36) @260 +@1742 := @1734 @95 +@1743 := @1662 @95 +@1748 := {ts : @148} -> (h : @1651) -> (hs : @271) -> @143 @1743 @260 +@1749 := @1742 @109 +@1750 := @1660 @95 +@1751 := @143 @1750 +@1754 := (h : @1655) -> (hs : @145) -> @1751 @112 +@1755 := @1749 @1653 +@1756 := @1658 @95 +@1758 := @143 @1756 @112 +@1759 := (hs : @145) -> @1758 +@1760 := @1755 @142 +@1762 := @143 @1657 @112 +@1763 := @221 @1648 +@1764 := @1638 @38 +@1765 := @29 @157 +@1766 := @96 @1765 +@1768 := @143 (@1766 @36) +@1774 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1764) -> (hs : @225) -> @1768 @171 +@1775 := @1763 @31 +@1780 := {vs : @147} -> {ts : @148} -> (h : @1643) -> (hs : @225) -> @1727 @260 +@1781 := @1775 @1657 +@1782 := @1751 @40 +@1783 := @1664 @1743 +@1788 := {ts : @148} -> (h : @1647) -> (hs : @1782) -> @143 @1783 @260 +@1789 := @1781 @112 +@1790 := @1662 @1750 +@1791 := @143 @1790 +@1794 := (h : @1651) -> (hs : @1758) -> @1791 @113 +@1795 := @1789 @1649 +@1796 := @1660 @1756 +@1798 := @143 @1796 @113 +@1799 := (hs : @1762) -> @1798 +@1800 := @1795 @1760 +@1802 := @143 @1659 @113 +@1803 := @221 @1644 +@1804 := @1634 @38 +@1805 := @29 @163 +@1806 := @96 @1805 +@1808 := @143 (@1806 @36) +@1814 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1804) -> (hs : @225) -> @1808 @171 +@1815 := @1803 @31 +@1820 := {vs : @147} -> {ts : @148} -> (h : @1639) -> (hs : @225) -> @1768 @260 +@1821 := @1815 @1659 +@1822 := @1791 @40 +@1823 := @1666 @1783 +@1828 := {ts : @148} -> (h : @1643) -> (hs : @1822) -> @143 @1823 @260 +@1829 := @1821 @113 +@1830 := @1664 @1790 +@1831 := @143 @1830 +@1834 := (h : @1647) -> (hs : @1798) -> @1831 @114 +@1835 := @1829 @1645 +@1836 := @1662 @1796 +@1838 := @143 @1836 @114 +@1839 := (hs : @1802) -> @1838 +@1840 := @1835 @1800 +@1842 := @143 @1661 @114 +@1843 := @221 @1640 +@1844 := @13 @1765 +@1845 := @1844 @38 +@1846 := #9 +@1847 := @29 @1846 +@1848 := @96 @1847 +@1850 := @143 (@1848 @36) +@1856 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1845) -> (hs : @225) -> @1850 @171 +@1857 := @1843 @31 +@1862 := {vs : @147} -> {ts : @148} -> (h : @1635) -> (hs : @225) -> @1808 @260 +@1863 := @1857 @1661 +@1864 := @1831 @40 +@1865 := @1766 @1823 +@1870 := {ts : @148} -> (h : @1639) -> (hs : @1864) -> @143 @1865 @260 +@1871 := @1863 @114 +@1872 := @1666 @1830 +@1873 := @143 @1872 +@1876 := (h : @1643) -> (hs : @1838) -> @1873 @115 +@1877 := @1871 @1641 +@1878 := @1664 @1836 +@1880 := @143 @1878 @115 +@1881 := (hs : @1842) -> @1880 +@1882 := @1877 @1840 +@1884 := @143 @1663 @115 +@1885 := @221 @1636 +@1886 := @13 @1805 +@1887 := @1886 @38 +@1888 := #10 +@1889 := @29 @1888 +@1890 := @96 @1889 +@1892 := @143 (@1890 @36) +@1898 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1887) -> (hs : @225) -> @1892 @171 +@1899 := @1885 @31 +@1900 := @1844 @31 +@1905 := {vs : @147} -> {ts : @148} -> (h : @1900) -> (hs : @225) -> @1850 @260 +@1906 := @1899 @1663 +@1907 := @1873 @40 +@1908 := @1806 @1865 +@1913 := {ts : @148} -> (h : @1635) -> (hs : @1907) -> @143 @1908 @260 +@1914 := @1906 @115 +@1915 := @1766 @1872 +@1916 := @143 @1915 +@1919 := (h : @1639) -> (hs : @1880) -> @1916 @116 +@1920 := @1914 @1637 +@1921 := @1666 @1878 +@1923 := @143 @1921 @116 +@1924 := (hs : @1884) -> @1923 +@1925 := @1920 @1882 +@1927 := @143 @1665 @116 +@1928 := @221 @1632 +@1930 := @13 @1847 @38 +@1931 := #11 +@1932 := @29 @1931 +@1933 := @96 @1932 +@1941 := {t : @92} -> + {vs : @147} -> {ts : @148} -> (h : @1930) -> (hs : @225) -> @143 (@1933 @36) @171 +@1942 := @1928 @31 +@1948 := {vs : @147} -> {ts : @148} -> (h : @1886 @31) -> (hs : @225) -> @1892 @260 +@1949 := @1942 @1665 +@1950 := @1916 @40 +@1951 := @1848 @1908 +@1952 := @143 @1951 +@1956 := {ts : @148} -> (h : @1900) -> (hs : @1950) -> @1952 @260 +@1957 := @1949 @116 +@1958 := @1806 @1915 +@1959 := @143 @1958 +@1962 := (h : @1635) -> (hs : @1923) -> @1959 @117 +@1963 := @1957 @1633 +@1964 := @1766 @1921 +@1965 := @143 @1964 +@1967 := (hs : @1927) -> @1965 @117 +@1968 := @1963 @1925 +@1969 := @143 @1667 +@1970 := @1969 @117 +@1971 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.denote +@1977 := @1971 @149 @151 @153 @36 @38 @40 +@1978 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.__fits_0 +@1984 := @1978 @149 @151 @153 @36 @38 @40 +@1992 := @29 (Reasoning.Main.gatewayLevel @149 @151 @153 @36 @38 @40) +@1999 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.root @149 @151 @153 @36 @38 @40 +@2000 := Bool +@2001 := Ne.{1} +@2002 := LexLeanPreservation.Obs +@2003 := @2001 @2002 +@2004 := LexLeanPreservation.Rel +@2007 := @2003 (@2004 @40 @4) +@2008 := LexLeanPreservation.Obs.stuck +@2011 := (f : @2000) -> (v : @91) -> @2007 @2008 +@2013 := LexLeanPreservation.Rust.rel_ne_stuck @1984 +@2024 := (v : @91) -> @2003 (@2004 (@1978 @157 @149 @151 @153 @36 @38) @4) @2008 +@2025 := @2013 @1992 +@2029 := @2003 (@2004 @1984 @1992) @2008 +@2030 := @146 @1670 +@2031 := LexLeanPreservation.Rust.FunSem +@2037 := (n : @35) -> @2031 @1846 @163 @157 @4 @149 +@2038 := @596 @1701 +@2039 := @595 @2038 +@2046 := LexLeanRuntime.index (@146 @1701) @1701 (LexLeanRuntime.instIndexableList @1701) +@2050 := @2039 (@2046 (@1702 @1846) @149) +@2051 := @604 @1701 +@2052 := @2051 @151 +@2053 := @2050 @2052 +@2057 := @118 @1888 @1846 @163 @151 +@2058 := LexLeanTarget.TargetSyntax.Function.types +@2059 := @2058 @149 +@2060 := @2057 @2059 +@2061 := @596 @2030 +@2062 := @595 @2061 +@2063 := LexLeanTarget.TargetSemantics.bindAll +@2064 := LexLeanTarget.TargetSyntax.Function.parameters +@2069 := @2062 (@2063 (@2064 @157) @149 @1686) +@2070 := @604 @2030 +@2071 := @2070 @151 +@2072 := @2069 @2071 +@2073 := @596 @2000 +@2074 := @595 @2073 +@2075 := LexLeanPreservation.Rust.fnFallible +@2078 := @2074 (@2075 @1931 @1846) +@2079 := @604 @2000 +@2080 := @2079 @151 +@2081 := @2078 @2080 +@2082 := LexLeanPreservation.RunConv +@2083 := #13 +@2087 := @2082 @2083 @1888 @163 @151 +@2089 := @2003 @149 @2008 +@2090 := Exists.{1} +@2091 := LexLeanPreservation.Rust.ROut +@2092 := @2090 @2091 +@2093 := And +@2094 := LexLeanPreservation.Rust.RealizesFn +@2098 := @2093 (@2094 @1846 @163 @4) +@2099 := LexLeanPreservation.Rust.RCI +@2100 := #15 +@2101 := @2099 @2100 +@2102 := LexLeanPreservation.Rust.fnIdent +@2103 := @2102 @2083 +@2110 := (hne : @2089) -> @2092 (fun (ro : @2091) => @2098 (@2101 @2103 @1931 @4)) +@2125 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2037) -> + (hfn : @2053) -> (hwt : @2060) -> (hbind : @2072) -> (hF : @2081) -> (hA : @2087) -> @2110 +@2127 := LexLeanPreservation.Rust.compose @0 +@2128 := @2031 @0 +@2133 := (n : @35) -> @2128 @163 @157 @4 @149 +@2134 := @2046 @1703 +@2137 := @2039 (@2134 @149) @2052 +@2141 := @129 @1846 @163 @151 @2059 +@2142 := @2082 @0 +@2145 := @2142 @1888 @163 @151 +@2159 := {c : @33} -> + {A : @34} -> + {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2133) -> + (hfn : @2137) -> (hwt : @2141) -> (hbind : @2072) -> (hF : @2081) -> (hA : @2145) -> @2110 +@2160 := @2127 @1 +@2161 := @2128 @1 +@2165 := (n : @35) -> @2161 @157 @4 @149 +@2168 := @137 @163 @151 @2059 +@2169 := @2075 @1 +@2172 := @2074 (@2169 @1846) @2080 +@2173 := @2099 @1 +@2183 := (hbind : @2072) -> + (hF : @2172) -> + (hA : @2145) -> (hne : @2089) -> @2092 (fun (ro : @2091) => @2098 (@2173 @2103 @1931 @4)) +@2193 := {A : @34} -> + {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> {o : @2002} -> (hB : @2165) -> (hfn : @2137) -> (hwt : @2168) -> @2183 +@2194 := @2160 @2 +@2196 := @2161 @2 @4 +@2198 := (n : @35) -> @2196 @149 +@2199 := @143 @151 +@2200 := @2199 @2059 +@2209 := {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> {o : @2002} -> (hB : @2198) -> (hfn : @2137) -> (hwt : @2200) -> @2183 +@2210 := @2194 @9 +@2212 := (n : @35) -> @2196 @9 +@2213 := @2134 @9 +@2214 := @2039 @2213 +@2215 := @2214 @2052 +@2216 := @2169 @9 +@2217 := @2074 @2216 +@2218 := @2217 @2080 +@2219 := @2142 @9 +@2221 := @2219 @163 @151 +@2223 := @2173 (@2102 @9) +@2231 := (hF : @2218) -> + (hA : @2221) -> (hne : @2089) -> @2092 (fun (ro : @2091) => @2098 (@2223 @1931 @4)) +@2240 := {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> (hB : @2212) -> (hfn : @2215) -> (hwt : @2200) -> (hbind : @2072) -> @2231 +@2241 := @2210 @1719 +@2243 := @2214 (@2051 @1719) +@2244 := @2058 @1719 +@2245 := @2199 @2244 +@2247 := @2063 (@2064 @1719) +@2259 := {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> (hwt : @2245) -> (hbind : @2062 (@2247 @149 @1686) @2071) -> @2231 +@2260 := @2241 @1667 +@2266 := @1933 (@1890 (@1848 (@1806 (@1766 (@1666 @95))))) +@2268 := @143 @2266 @2244 +@2269 := #12 +@2271 := @96 (@29 @2269) +@2277 := @2271 (@1933 (@1890 (@1848 (@1806 (@1766 @95))))) +@2281 := @2062 (@2247 @2277 @1686) @2071 +@2282 := #14 +@2284 := @96 (@29 @2282) +@2286 := @96 (@29 @2083) +@2292 := @2284 (@2286 (@2271 (@1933 (@1890 (@1848 @95))))) +@2294 := @2219 @2292 @151 +@2297 := @96 (@29 #17) +@2300 := @96 (@29 #16) +@2302 := @96 (@29 @2100) +@2323 := {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2268) -> + (hbind : @2281) -> + (hF : @2218) -> + (hA : @2294) -> + (hne : @2089) -> + @2092 (fun (ro : @2091) => @2098 (@2223 (@2297 (@2300 (@2302 (@2284 (@2286 (@2271 @95)))))) @4)) +@2324 := @2260 @1699 +@2330 := @1890 (@1848 (@1806 (@1766 (@1666 (@1664 @95))))) +@2332 := @143 @2330 @2244 +@2355 := @2062 + (@2247 @2266 @1686) + (@2070 + (@1687 + (@1674 @1632) + (@1687 + (@1676 @1765) + (@1687 + (@1678 @1805) + (@1687 (@1680 @1847) (@1687 (@1682 @1889) (@1687 (@1684 @1932) @1686))))))) +@2361 := @2286 (@2271 (@1933 (@1890 (@1848 (@1806 @95))))) +@2383 := {F : @2000} -> + {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2332) -> + (hbind : @2355) -> + (hF : @2218) -> + (hA : @2219 @2361 @151) -> + (hne : @2089) -> + @2092 (fun (ro : @2091) => @2098 (@2223 (@2300 (@2302 (@2284 (@2286 (@2271 (@1933 @95)))))) @4)) +@2384 := @2324 @1700 +@2385 := @1952 @2244 +@2408 := @2062 + (@2247 @2330 @1686) + (@2070 + (@1687 + (@1674 @1636) + (@1687 + (@1676 @1632) + (@1687 + (@1678 @1765) + (@1687 (@1680 @1805) (@1687 (@1682 @1847) (@1687 (@1684 @1889) @1686))))))) +@2410 := @2217 (@2079 @1700) +@2412 := @2219 @2277 @151 +@2413 := @2094 @1700 +@2435 := {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2385) -> + (hbind : @2408) -> + (hF : @2410) -> + (hA : @2412) -> + (hne : @2089) -> + @2092 + (fun (ro : @2091) => + @2093 (@2413 @163 @4) (@2223 (@2302 (@2284 (@2286 (@2271 (@1933 (@1890 @95)))))) @4)) +@2436 := @2384 @1977 +@2437 := @1959 @2244 +@2460 := @2062 + (@2247 @1951 @1686) + (@2070 + (@1687 + (@1674 @1640) + (@1687 + (@1676 @1636) + (@1687 + (@1678 @1632) + (@1687 (@1680 @1765) (@1687 (@1682 @1805) (@1687 (@1684 @1847) @1686))))))) +@2461 := @2219 @2266 +@2467 := @1971 @1931 @1888 @1846 @163 @157 @149 +@2468 := @2461 @2467 +@2474 := @1971 @2269 @1931 @1888 @1846 @163 @157 +@2497 := (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2437) -> + (hbind : @2460) -> + (hF : @2410) -> + (hA : @2468) -> + (hne : @2003 @2474 @2008) -> + @2092 + (fun (ro : @2091) => + @2093 (@2413 (@1971 @2282 @2083 @2269 @1931 @1888 @1846) @4) (@2223 @2292 @4)) +@2498 := @2436 @1723 +@2499 := @1965 @2244 +@2522 := @2062 + (@2247 @1958 @1686) + (@2070 + (@1687 + (@1674 @1644) + (@1687 + (@1676 @1640) + (@1687 + (@1678 @1636) + (@1687 (@1680 @1632) (@1687 (@1682 @1765) (@1687 (@1684 @1805) @1686))))))) +@2523 := @2219 @2330 +@2529 := @1971 @1888 @1846 @163 @157 @149 @151 +@2552 := (hfn : @2243) -> + (hwt : @2499) -> + (hbind : @2522) -> + (hF : @2410) -> + (hA : @2523 @2529) -> + (hne : @2003 @2467 @2008) -> + @2092 + (fun (ro : @2091) => + @2093 (@2413 (@1971 @2083 @2269 @1931 @1888 @1846 @163) @4) (@2223 @2361 @4)) +@2555 := @2498 (@704 @2038 @2213) +@2556 := @1969 @2244 +@2579 := @2062 + (@2247 @1964 @1686) + (@2070 + (@1687 + (@1674 @1648) + (@1687 + (@1676 @1644) + (@1687 + (@1678 @1640) + (@1687 (@1680 @1636) (@1687 (@1682 @1632) (@1687 (@1684 @1765) @1686))))))) +@2580 := @2219 @1951 +@2586 := @1971 @1846 @163 @157 @149 @151 @153 +@2602 := (hwt : @2556) -> + (hbind : @2579) -> + (hF : @2410) -> + (hA : @2580 @2586) -> + (hne : @2003 @2529 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2474 @4) (@2223 @2277 @4)) +@2603 := @2555 @1968 +@2605 := @2247 @1667 @1686 +@2608 := @2062 @2605 (@2070 @1699) +@2609 := @2219 @1958 +@2615 := @1971 @163 @157 @149 @151 @153 @36 +@2630 := (hbind : @2608) -> + (hF : @2410) -> + (hA : @2609 @2615) -> + (hne : @2003 @2586 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2467 @4) (@2223 @2266 @4)) +@2633 := @2603 (@704 @2061 @2605) +@2634 := @2219 @1964 +@2640 := @1971 @157 @149 @151 @153 @36 @38 +@2654 := (hF : @2410) -> + (hA : @2634 @2640) -> + (hne : @2003 @2615 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2529 @4) (@2223 @2330 @4)) +@2657 := @2633 (@704 @2073 @2216) +@2671 := (hA : @2219 @1667 @1977) -> + (hne : @2003 @2640 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2586 @4) (@2223 @1951 @4)) +@2672 := @2657 @1999 +@2683 := (hne : @2003 @1977 @2008) -> + @2092 (fun (ro : @2091) => @2093 (@2413 @2615 @4) (@2223 @1958 @4)) +@2684 := @2672 @2025 +@2690 := @2093 (@2413 @2640 @4) (@2223 @1964 @4) +@2692 := @2092 (fun (ro : @2091) => @2690) +@2694 := @2092 (fun (__e_ro : @2091) => @2690) +@2703 := LexLeanPreservation.Rust.RepresentableL + (@1664 (@1662 (@1660 (@1658 (@1656 (@96 @42 @95)))))) +@2704 := (__e_hrep : @2703) -> @2694 +@2705 := fun (__e_hrep : @2703) => @2684 +@2706 := (infection : @35) -> @2704 +@2707 := fun (infection : @35) => @2705 +@2708 := (systolic : @35) -> @2706 +@2709 := fun (systolic : @35) => @2707 +@2710 := (whiteCells : @35) -> @2708 +@2711 := fun (whiteCells : @35) => @2709 +@2712 := (respiratoryRate : @35) -> @2710 +@2713 := fun (respiratoryRate : @35) => @2711 +@2714 := (heartRate : @35) -> @2712 +@2715 := fun (heartRate : @35) => @2713 +@2716 := (temperature : @35) -> @2714 +@2717 := fun (temperature : @35) => @2715 +\end{coremodule} +\end{lexlean} diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R2/Compose/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R2/Compose/RustStd.lean deleted file mode 100644 index c8fff2edc..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R2/Compose/RustStd.lean +++ /dev/null @@ -1,38 +0,0 @@ -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2 -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd - -theorem __wt_0 : ∀ (__s : (Reasoning.Clinic.Vitals)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__enc_0 __s) (.adt 0) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).temperature) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).heartRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).respiratoryRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).whiteCells) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).systolic) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).infection) _root_.LexLeanPreservation.Rust.wtl_nil)))))) - -theorem __wt_1 : ∀ (__v : (Reasoning.Clinic.Triage.Step)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__enc_1 __v) (.adt 1) - | Reasoning.Clinic.Triage.Step.Fever => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Tachycardia => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Tachypnea => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Leukocytosis => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Sirs => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Sepsis => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Shock => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Clinic.Triage.Step.Escalate => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - -theorem __wt_3 : ∀ (__s : (Reasoning.Clinic.Chart)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__enc_3 __s) (.adt 3) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 (__s).vitals) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).fever) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).tachycardia) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).tachypnea) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).leukocytosis) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).sirs) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).sepsis) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).shock) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).level) _root_.LexLeanPreservation.Rust.wtl_nil))))))))) - -theorem __wt_4 : ∀ (__s : (Reasoning.Clinic.Triage.Ledger)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__enc_4 __s) (.adt 4) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).iterations) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).attempts) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).firings) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).expansions) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).verifications) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).frontier) _root_.LexLeanPreservation.Rust.wtl_nil)))))) - -theorem __wt_2 : ∀ (__s : (Reasoning.Clinic.Triage.Run)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__enc_2 __s) (.adt 2) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_3 (__s).state) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList __wt_1) (__s).trace) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_4 (__s).ledger) _root_.LexLeanPreservation.Rust.wtl_nil))) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteCells : Nat) (systolic : Nat) (infection : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.denote temperature heartRate respiratoryRate whiteCells systolic infection) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat temperature) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat heartRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat respiratoryRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat whiteCells) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat systolic) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat infection) _root_.LexLeanPreservation.Rust.wtl_nil)))))) rfl rfl (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.root temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R2/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R2/Compose/RustStd.lex.tex new file mode 100644 index 000000000..a6b45ef32 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R2/Compose/RustStd.lex.tex @@ -0,0 +1,1741 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2, + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_1 : @724 := @960 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_3 : @967 := @1631 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_3], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_4 : @1638 := @2091 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_4], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_2 : @2098 := @2458 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.root : @3543 := @3544 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.program +@1 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.krate +@2 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.flags +@3 := Reasoning.Clinic.Vitals +@4 := #0 +@5 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@16 := (__s : @3) -> @13 @6 @10 +@17 := Reasoning.Clinic.Vitals.temperature +@18 := @17 @4 +@19 := Reasoning.Clinic.Vitals.heartRate +@20 := @19 @4 +@21 := Reasoning.Clinic.Vitals.respiratoryRate +@22 := @21 @4 +@23 := Reasoning.Clinic.Vitals.whiteCells +@24 := @23 @4 +@25 := Reasoning.Clinic.Vitals.systolic +@26 := @25 @4 +@27 := Reasoning.Clinic.Vitals.infection +@28 := @27 @4 +@29 := LexLeanTarget.TargetSyntax.Value.nat +@30 := @29 @18 +@31 := LexLeanTarget.TargetSyntax.Ty.nat +@32 := LexLeanTarget.TargetSyntax.Program +@33 := LexLeanPreservation.Rust.RCrate +@34 := LexLeanPreservation.Rust.Flags +@35 := Nat +@36 := #3 +@37 := @7 @36 +@38 := #2 +@39 := @37 @38 +@40 := #1 +@41 := @39 @40 +@42 := @29 @4 +@48 := {p : @32} -> {c : @33} -> {A : @34} -> (n : @35) -> @41 @42 @31 +@50 := LexLeanPreservation.Rust.wt_nat @0 +@57 := {c : @33} -> {A : @34} -> (n : @35) -> @11 @38 @40 @42 @31 +@58 := @50 @1 +@63 := {A : @34} -> (n : @35) -> @12 @40 @42 @31 +@64 := @58 @2 +@67 := (n : @35) -> @13 @42 @31 +@68 := @64 @18 +@70 := @13 @30 @31 +@71 := @29 @20 +@72 := @64 @20 +@74 := @13 @71 @31 +@75 := @29 @22 +@76 := @64 @22 +@78 := @13 @75 @31 +@79 := @29 @24 +@80 := @64 @24 +@82 := @13 @79 @31 +@83 := @29 @26 +@84 := @64 @26 +@86 := @13 @83 @31 +@87 := @29 @28 +@88 := @64 @28 +@90 := @13 @87 @31 +@91 := LexLeanTarget.TargetSyntax.Value +@92 := LexLeanTarget.TargetSyntax.Ty +@93 := List.nil.{0} +@94 := List.cons.{0} +@95 := @93 @91 +@96 := @94 @91 +@98 := @96 @87 @95 +@100 := @96 @83 @98 +@102 := @96 @79 @100 +@104 := @96 @75 @102 +@106 := @96 @71 @104 +@108 := @96 @30 @106 +@109 := @93 @92 +@110 := @94 @92 +@111 := @110 @31 +@112 := @111 @109 +@113 := @111 @112 +@114 := @111 @113 +@115 := @111 @114 +@116 := @111 @115 +@117 := @111 @116 +@118 := LexLeanPreservation.Rust.WTL +@126 := {p : @32} -> {c : @33} -> {A : @34} -> @118 @38 @40 @4 @95 @109 +@128 := LexLeanPreservation.Rust.wtl_nil @0 +@129 := @118 @0 +@135 := {c : @33} -> {A : @34} -> @129 @40 @4 @95 @109 +@136 := @128 @1 +@137 := @129 @1 +@141 := {A : @34} -> @137 @4 @95 @109 +@142 := @136 @2 +@143 := @137 @2 +@144 := @143 @95 +@145 := @144 @109 +@146 := List.{0} +@147 := @146 @91 +@148 := @146 @92 +@149 := #6 +@150 := @7 @149 +@151 := #5 +@152 := @150 @151 +@153 := #4 +@154 := @152 @153 +@156 := @154 @36 @38 +@157 := #7 +@162 := @118 @157 @149 @151 @38 @40 +@163 := #8 +@166 := @118 @163 @157 @149 +@168 := @96 @151 @36 +@169 := @166 @168 +@171 := @110 @153 @38 +@181 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {v : @91} -> {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @156) -> (hs : @162) -> @169 @171 +@183 := LexLeanPreservation.Rust.wtl_cons @0 +@185 := @11 @151 @153 +@187 := @185 @36 @38 +@191 := @129 @149 @151 @38 @40 +@203 := {c : @33} -> + {A : @34} -> + {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @187) -> (hs : @191) -> @129 @157 @149 @168 @171 +@204 := @183 @1 +@205 := @12 @153 +@207 := @205 @36 @38 +@210 := @137 @151 @38 @40 +@220 := {A : @34} -> + {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @207) -> (hs : @210) -> @137 @149 @168 @171 +@221 := @204 @2 +@223 := @13 @36 @38 +@225 := @143 @38 @40 +@233 := {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @223) -> (hs : @225) -> @143 @168 @171 +@234 := @221 @87 +@236 := @29 (@27 @36) +@249 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @236 @38) -> (hs : @225) -> @143 (@96 (@29 (@27 @151)) @36) @171 +@250 := @234 @31 +@252 := @29 (@27 @38) +@254 := @13 @252 @31 +@259 := @143 (@96 (@29 (@27 @153)) @36) +@260 := @111 @38 +@265 := {vs : @147} -> {ts : @148} -> (h : @254) -> (hs : @225) -> @259 @260 +@266 := @250 @95 +@268 := @29 (@27 @40) +@270 := @13 @268 @31 +@271 := @144 @40 +@273 := @96 @236 @95 +@278 := {ts : @148} -> (h : @270) -> (hs : @271) -> @143 @273 @260 +@279 := @266 @109 +@281 := @96 @252 @95 +@282 := @143 @281 +@285 := (h : @90) -> (hs : @145) -> @282 @112 +@286 := @279 @88 +@288 := @96 @268 @95 +@290 := @143 @288 @112 +@291 := (hs : @145) -> @290 +@292 := @286 @142 +@294 := @143 @98 @112 +@295 := @221 @83 +@297 := @29 (@25 @36) +@310 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @297 @38) -> (hs : @225) -> @143 (@96 (@29 (@25 @151)) @36) @171 +@311 := @295 @31 +@313 := @29 (@25 @38) +@325 := {vs : @147} -> + {ts : @148} -> (h : @13 @313 @31) -> (hs : @225) -> @143 (@96 (@29 (@25 @153)) @36) @260 +@326 := @311 @98 +@328 := @29 (@25 @40) +@330 := @13 @328 @31 +@331 := @282 @40 +@333 := @96 @297 @273 +@338 := {ts : @148} -> (h : @330) -> (hs : @331) -> @143 @333 @260 +@339 := @326 @112 +@341 := @96 @313 @281 +@342 := @143 @341 +@345 := (h : @86) -> (hs : @290) -> @342 @113 +@346 := @339 @84 +@348 := @96 @328 @288 +@350 := @143 @348 @113 +@351 := (hs : @294) -> @350 +@352 := @346 @292 +@354 := @143 @100 @113 +@355 := @221 @79 +@357 := @29 (@23 @36) +@370 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @357 @38) -> (hs : @225) -> @143 (@96 (@29 (@23 @151)) @36) @171 +@371 := @355 @31 +@373 := @29 (@23 @38) +@385 := {vs : @147} -> + {ts : @148} -> (h : @13 @373 @31) -> (hs : @225) -> @143 (@96 (@29 (@23 @153)) @36) @260 +@386 := @371 @100 +@388 := @29 (@23 @40) +@390 := @13 @388 @31 +@391 := @342 @40 +@393 := @96 @357 @333 +@398 := {ts : @148} -> (h : @390) -> (hs : @391) -> @143 @393 @260 +@399 := @386 @113 +@401 := @96 @373 @341 +@402 := @143 @401 +@405 := (h : @82) -> (hs : @350) -> @402 @114 +@406 := @399 @80 +@408 := @96 @388 @348 +@410 := @143 @408 @114 +@411 := (hs : @354) -> @410 +@412 := @406 @352 +@414 := @143 @102 @114 +@415 := @221 @75 +@417 := @29 (@21 @36) +@430 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @417 @38) -> (hs : @225) -> @143 (@96 (@29 (@21 @151)) @36) @171 +@431 := @415 @31 +@433 := @29 (@21 @38) +@445 := {vs : @147} -> + {ts : @148} -> (h : @13 @433 @31) -> (hs : @225) -> @143 (@96 (@29 (@21 @153)) @36) @260 +@446 := @431 @102 +@448 := @29 (@21 @40) +@450 := @13 @448 @31 +@451 := @402 @40 +@453 := @96 @417 @393 +@458 := {ts : @148} -> (h : @450) -> (hs : @451) -> @143 @453 @260 +@459 := @446 @114 +@461 := @96 @433 @401 +@462 := @143 @461 +@465 := (h : @78) -> (hs : @410) -> @462 @115 +@466 := @459 @76 +@468 := @96 @448 @408 +@470 := @143 @468 @115 +@471 := (hs : @414) -> @470 +@472 := @466 @412 +@474 := @143 @104 @115 +@475 := @221 @71 +@477 := @29 (@19 @36) +@490 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @477 @38) -> (hs : @225) -> @143 (@96 (@29 (@19 @151)) @36) @171 +@491 := @475 @31 +@493 := @29 (@19 @38) +@505 := {vs : @147} -> + {ts : @148} -> (h : @13 @493 @31) -> (hs : @225) -> @143 (@96 (@29 (@19 @153)) @36) @260 +@506 := @491 @104 +@508 := @29 (@19 @40) +@510 := @13 @508 @31 +@511 := @462 @40 +@513 := @96 @477 @453 +@518 := {ts : @148} -> (h : @510) -> (hs : @511) -> @143 @513 @260 +@519 := @506 @115 +@521 := @96 @493 @461 +@522 := @143 @521 +@525 := (h : @74) -> (hs : @470) -> @522 @116 +@526 := @519 @72 +@528 := @96 @508 @468 +@530 := @143 @528 @116 +@531 := (hs : @474) -> @530 +@532 := @526 @472 +@534 := @143 @106 @116 +@535 := @221 @30 +@537 := @29 (@17 @36) +@550 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @537 @38) -> (hs : @225) -> @143 (@96 (@29 (@17 @151)) @36) @171 +@551 := @535 @31 +@553 := @29 (@17 @38) +@565 := {vs : @147} -> + {ts : @148} -> (h : @13 @553 @31) -> (hs : @225) -> @143 (@96 (@29 (@17 @153)) @36) @260 +@566 := @551 @106 +@568 := @29 (@17 @40) +@570 := @13 @568 @31 +@571 := @522 @40 +@573 := @96 @537 @513 +@578 := {ts : @148} -> (h : @570) -> (hs : @571) -> @143 @573 @260 +@579 := @566 @116 +@581 := @96 @553 @521 +@582 := @143 @581 +@585 := (h : @70) -> (hs : @530) -> @582 @117 +@586 := @579 @68 +@588 := @96 @568 @528 +@590 := @143 @588 @117 +@591 := (hs : @534) -> @590 +@592 := @586 @532 +@594 := @143 @108 @117 +@595 := Eq.{1} +@596 := Option.{0} +@597 := @596 @148 +@598 := @595 @597 +@599 := LexLeanPreservation.Rust.adtFields +@603 := @598 (@599 @149 @36 @38) +@604 := Option.some.{0} +@605 := @604 @148 +@606 := @605 @4 +@607 := @603 @606 +@610 := @7 @163 @157 @149 +@611 := LexLeanTarget.TargetSyntax.Value.adt +@613 := @611 @153 @36 +@614 := @610 @613 +@615 := @8 @151 +@625 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {i : @35} -> {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @607) -> (hf : @162) -> @614 @615 +@627 := LexLeanPreservation.Rust.wt_adt @0 +@628 := @599 @0 +@632 := @598 (@628 @36 @38) @606 +@644 := {c : @33} -> + {A : @34} -> + {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @191) -> @11 @157 @149 @613 @615 +@645 := @627 @1 +@655 := {A : @34} -> + {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @210) -> @12 @149 @613 @615 +@656 := @645 @2 +@657 := @13 @613 +@664 := {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @225) -> @657 @615 +@665 := @656 @9 +@666 := @628 @9 +@675 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@666 @38) @606) -> (hf : @225) -> @657 @10 +@676 := @665 @9 +@677 := @666 @9 +@678 := @598 @677 +@679 := @678 @606 +@680 := @611 @9 +@682 := @13 (@680 @36) +@687 := {fs : @147} -> {tys : @148} -> (h : @679) -> (hf : @225) -> @682 @10 +@688 := @676 @108 +@695 := {tys : @148} -> (h : @679) -> (hf : @582 @40) -> @13 (@680 @573) @10 +@696 := @688 @117 +@697 := @605 @117 +@703 := (h : @678 @697) -> (hf : @590) -> @13 (@680 @581) @10 +@704 := Eq.refl.{1} +@705 := @704 @597 +@707 := @696 (@705 @677) +@711 := (hf : @594) -> @13 (@680 @588) @10 +@712 := @707 @592 +@715 := @13 (@680 @108) @10 +@716 := fun (__s : @3) => @712 +@717 := Reasoning.Clinic.Triage.Step +@718 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__enc_1 +@719 := @718 @4 +@720 := 1 +@721 := @8 @720 +@722 := @13 @719 +@723 := @722 @721 +@724 := (__v : @717) -> @723 +@725 := fun (__v : @717) => @723 +@726 := @656 @720 +@727 := @628 @720 +@736 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@727 @38) @606) -> (hf : @225) -> @657 @721 +@737 := @726 @9 +@738 := @727 @9 +@739 := @598 @738 +@740 := @739 @606 +@745 := {fs : @147} -> {tys : @148} -> (h : @740) -> (hf : @225) -> @682 @721 +@746 := @737 @95 +@749 := @13 (@680 @95) @721 +@752 := {tys : @148} -> (h : @740) -> (hf : @271) -> @749 +@753 := @746 @109 +@754 := @605 @109 +@757 := (h : @739 @754) -> (hf : @145) -> @749 +@760 := @753 (@705 @738) @142 +@761 := @726 @720 +@762 := @727 @720 +@763 := @598 @762 +@764 := @763 @606 +@765 := @611 @720 +@772 := {fs : @147} -> {tys : @148} -> (h : @764) -> (hf : @225) -> @13 (@765 @36) @721 +@773 := @761 @95 +@776 := @13 (@765 @95) @721 +@779 := {tys : @148} -> (h : @764) -> (hf : @271) -> @776 +@780 := @773 @109 +@783 := (h : @763 @754) -> (hf : @145) -> @776 +@786 := @780 (@705 @762) @142 +@787 := 2 +@788 := @726 @787 +@789 := @727 @787 +@790 := @598 @789 +@791 := @790 @606 +@792 := @611 @787 +@799 := {fs : @147} -> {tys : @148} -> (h : @791) -> (hf : @225) -> @13 (@792 @36) @721 +@800 := @788 @95 +@803 := @13 (@792 @95) @721 +@806 := {tys : @148} -> (h : @791) -> (hf : @271) -> @803 +@807 := @800 @109 +@810 := (h : @790 @754) -> (hf : @145) -> @803 +@813 := @807 (@705 @789) @142 +@814 := 3 +@815 := @726 @814 +@816 := @727 @814 +@817 := @598 @816 +@818 := @817 @606 +@819 := @611 @814 +@826 := {fs : @147} -> {tys : @148} -> (h : @818) -> (hf : @225) -> @13 (@819 @36) @721 +@827 := @815 @95 +@830 := @13 (@819 @95) @721 +@833 := {tys : @148} -> (h : @818) -> (hf : @271) -> @830 +@834 := @827 @109 +@837 := (h : @817 @754) -> (hf : @145) -> @830 +@840 := @834 (@705 @816) @142 +@841 := 4 +@842 := @726 @841 +@843 := @727 @841 +@844 := @598 @843 +@845 := @844 @606 +@846 := @611 @841 +@853 := {fs : @147} -> {tys : @148} -> (h : @845) -> (hf : @225) -> @13 (@846 @36) @721 +@854 := @842 @95 +@857 := @13 (@846 @95) @721 +@860 := {tys : @148} -> (h : @845) -> (hf : @271) -> @857 +@861 := @854 @109 +@864 := (h : @844 @754) -> (hf : @145) -> @857 +@867 := @861 (@705 @843) @142 +@868 := 5 +@869 := @726 @868 +@870 := @727 @868 +@871 := @598 @870 +@872 := @871 @606 +@873 := @611 @868 +@880 := {fs : @147} -> {tys : @148} -> (h : @872) -> (hf : @225) -> @13 (@873 @36) @721 +@881 := @869 @95 +@884 := @13 (@873 @95) @721 +@887 := {tys : @148} -> (h : @872) -> (hf : @271) -> @884 +@888 := @881 @109 +@891 := (h : @871 @754) -> (hf : @145) -> @884 +@894 := @888 (@705 @870) @142 +@895 := 6 +@896 := @726 @895 +@897 := @727 @895 +@898 := @598 @897 +@899 := @898 @606 +@900 := @611 @895 +@907 := {fs : @147} -> {tys : @148} -> (h : @899) -> (hf : @225) -> @13 (@900 @36) @721 +@908 := @896 @95 +@911 := @13 (@900 @95) @721 +@914 := {tys : @148} -> (h : @899) -> (hf : @271) -> @911 +@915 := @908 @109 +@918 := (h : @898 @754) -> (hf : @145) -> @911 +@921 := @915 (@705 @897) @142 +@922 := 7 +@923 := @726 @922 +@924 := @727 @922 +@925 := @598 @924 +@926 := @925 @606 +@927 := @611 @922 +@934 := {fs : @147} -> {tys : @148} -> (h : @926) -> (hf : @225) -> @13 (@927 @36) @721 +@935 := @923 @95 +@938 := @13 (@927 @95) @721 +@941 := {tys : @148} -> (h : @926) -> (hf : @271) -> @938 +@942 := @935 @109 +@945 := (h : @925 @754) -> (hf : @145) -> @938 +@948 := @942 (@705 @924) @142 +@960 := fun (__v : @717) => + Reasoning.Clinic.Triage.Step.casesOn.{0} @725 @4 @760 @786 @813 @840 @867 @894 @921 @948 +@961 := Reasoning.Clinic.Chart +@962 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__enc_3 +@963 := @962 @4 +@964 := @8 @814 +@967 := (__s : @961) -> @13 @963 @964 +@968 := Reasoning.Clinic.Chart.vitals +@969 := @968 @4 +@970 := Reasoning.Clinic.Chart.fever +@971 := @970 @4 +@972 := Reasoning.Clinic.Chart.tachycardia +@973 := @972 @4 +@974 := Reasoning.Clinic.Chart.tachypnea +@975 := @974 @4 +@976 := Reasoning.Clinic.Chart.leukocytosis +@977 := @976 @4 +@978 := Reasoning.Clinic.Chart.sirs +@979 := @978 @4 +@980 := Reasoning.Clinic.Chart.sepsis +@981 := @980 @4 +@982 := Reasoning.Clinic.Chart.shock +@983 := @982 @4 +@984 := Reasoning.Clinic.Chart.level +@985 := @984 @4 +@986 := @5 @969 +@988 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_0 @969 +@989 := @29 @971 +@990 := @64 @971 +@992 := @13 @989 @31 +@993 := @29 @973 +@994 := @64 @973 +@996 := @13 @993 @31 +@997 := @29 @975 +@998 := @64 @975 +@1000 := @13 @997 @31 +@1001 := @29 @977 +@1002 := @64 @977 +@1004 := @13 @1001 @31 +@1005 := @29 @979 +@1006 := @64 @979 +@1008 := @13 @1005 @31 +@1009 := @29 @981 +@1010 := @64 @981 +@1012 := @13 @1009 @31 +@1013 := @29 @983 +@1014 := @64 @983 +@1016 := @13 @1013 @31 +@1017 := @29 @985 +@1018 := @64 @985 +@1020 := @13 @1017 @31 +@1022 := @96 @1017 @95 +@1024 := @96 @1013 @1022 +@1026 := @96 @1009 @1024 +@1028 := @96 @1005 @1026 +@1030 := @96 @1001 @1028 +@1032 := @96 @997 @1030 +@1034 := @96 @993 @1032 +@1036 := @96 @989 @1034 +@1038 := @96 @986 @1036 +@1039 := @111 @117 +@1040 := @111 @1039 +@1041 := @110 @10 +@1042 := @1041 @1040 +@1043 := @221 @1017 +@1045 := @29 (@984 @36) +@1058 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1045 @38) -> (hs : @225) -> @143 (@96 (@29 (@984 @151)) @36) @171 +@1059 := @1043 @31 +@1061 := @29 (@984 @38) +@1073 := {vs : @147} -> + {ts : @148} -> (h : @13 @1061 @31) -> (hs : @225) -> @143 (@96 (@29 (@984 @153)) @36) @260 +@1074 := @1059 @95 +@1076 := @29 (@984 @40) +@1078 := @13 @1076 @31 +@1080 := @96 @1045 @95 +@1085 := {ts : @148} -> (h : @1078) -> (hs : @271) -> @143 @1080 @260 +@1086 := @1074 @109 +@1088 := @96 @1061 @95 +@1089 := @143 @1088 +@1092 := (h : @1020) -> (hs : @145) -> @1089 @112 +@1093 := @1086 @1018 +@1095 := @96 @1076 @95 +@1097 := @143 @1095 @112 +@1098 := (hs : @145) -> @1097 +@1099 := @1093 @142 +@1101 := @143 @1022 @112 +@1102 := @221 @1013 +@1104 := @29 (@982 @36) +@1117 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1104 @38) -> (hs : @225) -> @143 (@96 (@29 (@982 @151)) @36) @171 +@1118 := @1102 @31 +@1120 := @29 (@982 @38) +@1132 := {vs : @147} -> + {ts : @148} -> (h : @13 @1120 @31) -> (hs : @225) -> @143 (@96 (@29 (@982 @153)) @36) @260 +@1133 := @1118 @1022 +@1135 := @29 (@982 @40) +@1137 := @13 @1135 @31 +@1138 := @1089 @40 +@1140 := @96 @1104 @1080 +@1145 := {ts : @148} -> (h : @1137) -> (hs : @1138) -> @143 @1140 @260 +@1146 := @1133 @112 +@1148 := @96 @1120 @1088 +@1149 := @143 @1148 +@1152 := (h : @1016) -> (hs : @1097) -> @1149 @113 +@1153 := @1146 @1014 +@1155 := @96 @1135 @1095 +@1157 := @143 @1155 @113 +@1158 := (hs : @1101) -> @1157 +@1159 := @1153 @1099 +@1161 := @143 @1024 @113 +@1162 := @221 @1009 +@1164 := @29 (@980 @36) +@1177 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1164 @38) -> (hs : @225) -> @143 (@96 (@29 (@980 @151)) @36) @171 +@1178 := @1162 @31 +@1180 := @29 (@980 @38) +@1192 := {vs : @147} -> + {ts : @148} -> (h : @13 @1180 @31) -> (hs : @225) -> @143 (@96 (@29 (@980 @153)) @36) @260 +@1193 := @1178 @1024 +@1195 := @29 (@980 @40) +@1197 := @13 @1195 @31 +@1198 := @1149 @40 +@1200 := @96 @1164 @1140 +@1205 := {ts : @148} -> (h : @1197) -> (hs : @1198) -> @143 @1200 @260 +@1206 := @1193 @113 +@1208 := @96 @1180 @1148 +@1209 := @143 @1208 +@1212 := (h : @1012) -> (hs : @1157) -> @1209 @114 +@1213 := @1206 @1010 +@1215 := @96 @1195 @1155 +@1217 := @143 @1215 @114 +@1218 := (hs : @1161) -> @1217 +@1219 := @1213 @1159 +@1221 := @143 @1026 @114 +@1222 := @221 @1005 +@1224 := @29 (@978 @36) +@1237 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1224 @38) -> (hs : @225) -> @143 (@96 (@29 (@978 @151)) @36) @171 +@1238 := @1222 @31 +@1240 := @29 (@978 @38) +@1252 := {vs : @147} -> + {ts : @148} -> (h : @13 @1240 @31) -> (hs : @225) -> @143 (@96 (@29 (@978 @153)) @36) @260 +@1253 := @1238 @1026 +@1255 := @29 (@978 @40) +@1257 := @13 @1255 @31 +@1258 := @1209 @40 +@1260 := @96 @1224 @1200 +@1265 := {ts : @148} -> (h : @1257) -> (hs : @1258) -> @143 @1260 @260 +@1266 := @1253 @114 +@1268 := @96 @1240 @1208 +@1269 := @143 @1268 +@1272 := (h : @1008) -> (hs : @1217) -> @1269 @115 +@1273 := @1266 @1006 +@1275 := @96 @1255 @1215 +@1277 := @143 @1275 @115 +@1278 := (hs : @1221) -> @1277 +@1279 := @1273 @1219 +@1281 := @143 @1028 @115 +@1282 := @221 @1001 +@1284 := @29 (@976 @36) +@1297 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1284 @38) -> (hs : @225) -> @143 (@96 (@29 (@976 @151)) @36) @171 +@1298 := @1282 @31 +@1300 := @29 (@976 @38) +@1312 := {vs : @147} -> + {ts : @148} -> (h : @13 @1300 @31) -> (hs : @225) -> @143 (@96 (@29 (@976 @153)) @36) @260 +@1313 := @1298 @1028 +@1315 := @29 (@976 @40) +@1317 := @13 @1315 @31 +@1318 := @1269 @40 +@1320 := @96 @1284 @1260 +@1325 := {ts : @148} -> (h : @1317) -> (hs : @1318) -> @143 @1320 @260 +@1326 := @1313 @115 +@1328 := @96 @1300 @1268 +@1329 := @143 @1328 +@1332 := (h : @1004) -> (hs : @1277) -> @1329 @116 +@1333 := @1326 @1002 +@1335 := @96 @1315 @1275 +@1337 := @143 @1335 @116 +@1338 := (hs : @1281) -> @1337 +@1339 := @1333 @1279 +@1341 := @143 @1030 @116 +@1342 := @221 @997 +@1344 := @29 (@974 @36) +@1357 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1344 @38) -> (hs : @225) -> @143 (@96 (@29 (@974 @151)) @36) @171 +@1358 := @1342 @31 +@1360 := @29 (@974 @38) +@1372 := {vs : @147} -> + {ts : @148} -> (h : @13 @1360 @31) -> (hs : @225) -> @143 (@96 (@29 (@974 @153)) @36) @260 +@1373 := @1358 @1030 +@1375 := @29 (@974 @40) +@1377 := @13 @1375 @31 +@1378 := @1329 @40 +@1380 := @96 @1344 @1320 +@1385 := {ts : @148} -> (h : @1377) -> (hs : @1378) -> @143 @1380 @260 +@1386 := @1373 @116 +@1388 := @96 @1360 @1328 +@1389 := @143 @1388 +@1392 := (h : @1000) -> (hs : @1337) -> @1389 @117 +@1393 := @1386 @998 +@1395 := @96 @1375 @1335 +@1397 := @143 @1395 @117 +@1398 := (hs : @1341) -> @1397 +@1399 := @1393 @1339 +@1401 := @143 @1032 @117 +@1402 := @221 @993 +@1404 := @29 (@972 @36) +@1417 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1404 @38) -> (hs : @225) -> @143 (@96 (@29 (@972 @151)) @36) @171 +@1418 := @1402 @31 +@1420 := @29 (@972 @38) +@1432 := {vs : @147} -> + {ts : @148} -> (h : @13 @1420 @31) -> (hs : @225) -> @143 (@96 (@29 (@972 @153)) @36) @260 +@1433 := @1418 @1032 +@1435 := @29 (@972 @40) +@1437 := @13 @1435 @31 +@1438 := @1389 @40 +@1440 := @96 @1404 @1380 +@1445 := {ts : @148} -> (h : @1437) -> (hs : @1438) -> @143 @1440 @260 +@1446 := @1433 @117 +@1448 := @96 @1420 @1388 +@1449 := @143 @1448 +@1452 := (h : @996) -> (hs : @1397) -> @1449 @1039 +@1453 := @1446 @994 +@1455 := @96 @1435 @1395 +@1457 := @143 @1455 @1039 +@1458 := (hs : @1401) -> @1457 +@1459 := @1453 @1399 +@1461 := @143 @1034 @1039 +@1462 := @221 @989 +@1464 := @29 (@970 @36) +@1477 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1464 @38) -> (hs : @225) -> @143 (@96 (@29 (@970 @151)) @36) @171 +@1478 := @1462 @31 +@1480 := @29 (@970 @38) +@1492 := {vs : @147} -> + {ts : @148} -> (h : @13 @1480 @31) -> (hs : @225) -> @143 (@96 (@29 (@970 @153)) @36) @260 +@1493 := @1478 @1034 +@1495 := @29 (@970 @40) +@1497 := @13 @1495 @31 +@1498 := @1449 @40 +@1500 := @96 @1464 @1440 +@1505 := {ts : @148} -> (h : @1497) -> (hs : @1498) -> @143 @1500 @260 +@1506 := @1493 @1039 +@1508 := @96 @1480 @1448 +@1509 := @143 @1508 +@1512 := (h : @992) -> (hs : @1457) -> @1509 @1040 +@1513 := @1506 @990 +@1515 := @96 @1495 @1455 +@1517 := @143 @1515 @1040 +@1518 := (hs : @1461) -> @1517 +@1519 := @1513 @1459 +@1521 := @143 @1036 @1040 +@1522 := @221 @986 +@1524 := @5 (@968 @36) +@1537 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1524 @38) -> (hs : @225) -> @143 (@96 (@5 (@968 @151)) @36) @171 +@1538 := @1522 @10 +@1540 := @5 (@968 @38) +@1542 := @13 @1540 @10 +@1547 := @143 (@96 (@5 (@968 @153)) @36) +@1548 := @1041 @38 +@1553 := {vs : @147} -> {ts : @148} -> (h : @1542) -> (hs : @225) -> @1547 @1548 +@1554 := @1538 @1036 +@1556 := @5 (@968 @40) +@1558 := @13 @1556 @10 +@1559 := @1509 @40 +@1561 := @96 @1524 @1500 +@1566 := {ts : @148} -> (h : @1558) -> (hs : @1559) -> @143 @1561 @1548 +@1567 := @1554 @1040 +@1569 := @13 @986 @10 +@1571 := @96 @1540 @1508 +@1572 := @143 @1571 +@1575 := (h : @1569) -> (hs : @1517) -> @1572 @1042 +@1576 := @1567 @988 +@1578 := @96 @1556 @1515 +@1580 := @143 @1578 @1042 +@1581 := (hs : @1521) -> @1580 +@1582 := @1576 @1519 +@1584 := @143 @1038 @1042 +@1585 := @656 @814 +@1586 := @628 @814 +@1595 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@1586 @38) @606) -> (hf : @225) -> @657 @964 +@1596 := @1585 @9 +@1597 := @1586 @9 +@1598 := @598 @1597 +@1599 := @1598 @606 +@1604 := {fs : @147} -> {tys : @148} -> (h : @1599) -> (hf : @225) -> @682 @964 +@1605 := @1596 @1038 +@1612 := {tys : @148} -> (h : @1599) -> (hf : @1572 @40) -> @13 (@680 @1561) @964 +@1613 := @1605 @1042 +@1620 := (h : @1598 (@605 @1042)) -> (hf : @1580) -> @13 (@680 @1571) @964 +@1622 := @1613 (@705 @1597) +@1626 := (hf : @1584) -> @13 (@680 @1578) @964 +@1627 := @1622 @1582 +@1630 := @13 (@680 @1038) @964 +@1631 := fun (__s : @961) => @1627 +@1632 := Reasoning.Clinic.Triage.Ledger +@1633 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__enc_4 +@1634 := @1633 @4 +@1635 := @8 @841 +@1638 := (__s : @1632) -> @13 @1634 @1635 +@1639 := Reasoning.Clinic.Triage.Ledger.iterations +@1640 := @1639 @4 +@1641 := Reasoning.Clinic.Triage.Ledger.attempts +@1642 := @1641 @4 +@1643 := Reasoning.Clinic.Triage.Ledger.firings +@1644 := @1643 @4 +@1645 := Reasoning.Clinic.Triage.Ledger.expansions +@1646 := @1645 @4 +@1647 := Reasoning.Clinic.Triage.Ledger.verifications +@1648 := @1647 @4 +@1649 := Reasoning.Clinic.Triage.Ledger.frontier +@1650 := @1649 @4 +@1651 := @29 @1640 +@1652 := @64 @1640 +@1654 := @13 @1651 @31 +@1655 := @29 @1642 +@1656 := @64 @1642 +@1658 := @13 @1655 @31 +@1659 := @29 @1644 +@1660 := @64 @1644 +@1662 := @13 @1659 @31 +@1663 := @29 @1646 +@1664 := @64 @1646 +@1666 := @13 @1663 @31 +@1667 := @29 @1648 +@1668 := @64 @1648 +@1670 := @13 @1667 @31 +@1671 := @29 @1650 +@1672 := @64 @1650 +@1674 := @13 @1671 @31 +@1676 := @96 @1671 @95 +@1678 := @96 @1667 @1676 +@1680 := @96 @1663 @1678 +@1682 := @96 @1659 @1680 +@1684 := @96 @1655 @1682 +@1686 := @96 @1651 @1684 +@1687 := @221 @1671 +@1689 := @29 (@1649 @36) +@1702 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1689 @38) -> (hs : @225) -> @143 (@96 (@29 (@1649 @151)) @36) @171 +@1703 := @1687 @31 +@1705 := @29 (@1649 @38) +@1717 := {vs : @147} -> + {ts : @148} -> (h : @13 @1705 @31) -> (hs : @225) -> @143 (@96 (@29 (@1649 @153)) @36) @260 +@1718 := @1703 @95 +@1720 := @29 (@1649 @40) +@1722 := @13 @1720 @31 +@1724 := @96 @1689 @95 +@1729 := {ts : @148} -> (h : @1722) -> (hs : @271) -> @143 @1724 @260 +@1730 := @1718 @109 +@1732 := @96 @1705 @95 +@1733 := @143 @1732 +@1736 := (h : @1674) -> (hs : @145) -> @1733 @112 +@1737 := @1730 @1672 +@1739 := @96 @1720 @95 +@1741 := @143 @1739 @112 +@1742 := (hs : @145) -> @1741 +@1743 := @1737 @142 +@1745 := @143 @1676 @112 +@1746 := @221 @1667 +@1748 := @29 (@1647 @36) +@1761 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1748 @38) -> (hs : @225) -> @143 (@96 (@29 (@1647 @151)) @36) @171 +@1762 := @1746 @31 +@1764 := @29 (@1647 @38) +@1776 := {vs : @147} -> + {ts : @148} -> (h : @13 @1764 @31) -> (hs : @225) -> @143 (@96 (@29 (@1647 @153)) @36) @260 +@1777 := @1762 @1676 +@1779 := @29 (@1647 @40) +@1781 := @13 @1779 @31 +@1782 := @1733 @40 +@1784 := @96 @1748 @1724 +@1789 := {ts : @148} -> (h : @1781) -> (hs : @1782) -> @143 @1784 @260 +@1790 := @1777 @112 +@1792 := @96 @1764 @1732 +@1793 := @143 @1792 +@1796 := (h : @1670) -> (hs : @1741) -> @1793 @113 +@1797 := @1790 @1668 +@1799 := @96 @1779 @1739 +@1801 := @143 @1799 @113 +@1802 := (hs : @1745) -> @1801 +@1803 := @1797 @1743 +@1805 := @143 @1678 @113 +@1806 := @221 @1663 +@1808 := @29 (@1645 @36) +@1821 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1808 @38) -> (hs : @225) -> @143 (@96 (@29 (@1645 @151)) @36) @171 +@1822 := @1806 @31 +@1824 := @29 (@1645 @38) +@1836 := {vs : @147} -> + {ts : @148} -> (h : @13 @1824 @31) -> (hs : @225) -> @143 (@96 (@29 (@1645 @153)) @36) @260 +@1837 := @1822 @1678 +@1839 := @29 (@1645 @40) +@1841 := @13 @1839 @31 +@1842 := @1793 @40 +@1844 := @96 @1808 @1784 +@1849 := {ts : @148} -> (h : @1841) -> (hs : @1842) -> @143 @1844 @260 +@1850 := @1837 @113 +@1852 := @96 @1824 @1792 +@1853 := @143 @1852 +@1856 := (h : @1666) -> (hs : @1801) -> @1853 @114 +@1857 := @1850 @1664 +@1859 := @96 @1839 @1799 +@1861 := @143 @1859 @114 +@1862 := (hs : @1805) -> @1861 +@1863 := @1857 @1803 +@1865 := @143 @1680 @114 +@1866 := @221 @1659 +@1868 := @29 (@1643 @36) +@1881 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1868 @38) -> (hs : @225) -> @143 (@96 (@29 (@1643 @151)) @36) @171 +@1882 := @1866 @31 +@1884 := @29 (@1643 @38) +@1896 := {vs : @147} -> + {ts : @148} -> (h : @13 @1884 @31) -> (hs : @225) -> @143 (@96 (@29 (@1643 @153)) @36) @260 +@1897 := @1882 @1680 +@1899 := @29 (@1643 @40) +@1901 := @13 @1899 @31 +@1902 := @1853 @40 +@1904 := @96 @1868 @1844 +@1909 := {ts : @148} -> (h : @1901) -> (hs : @1902) -> @143 @1904 @260 +@1910 := @1897 @114 +@1912 := @96 @1884 @1852 +@1913 := @143 @1912 +@1916 := (h : @1662) -> (hs : @1861) -> @1913 @115 +@1917 := @1910 @1660 +@1919 := @96 @1899 @1859 +@1921 := @143 @1919 @115 +@1922 := (hs : @1865) -> @1921 +@1923 := @1917 @1863 +@1925 := @143 @1682 @115 +@1926 := @221 @1655 +@1928 := @29 (@1641 @36) +@1941 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1928 @38) -> (hs : @225) -> @143 (@96 (@29 (@1641 @151)) @36) @171 +@1942 := @1926 @31 +@1944 := @29 (@1641 @38) +@1956 := {vs : @147} -> + {ts : @148} -> (h : @13 @1944 @31) -> (hs : @225) -> @143 (@96 (@29 (@1641 @153)) @36) @260 +@1957 := @1942 @1682 +@1959 := @29 (@1641 @40) +@1961 := @13 @1959 @31 +@1962 := @1913 @40 +@1964 := @96 @1928 @1904 +@1969 := {ts : @148} -> (h : @1961) -> (hs : @1962) -> @143 @1964 @260 +@1970 := @1957 @115 +@1972 := @96 @1944 @1912 +@1973 := @143 @1972 +@1976 := (h : @1658) -> (hs : @1921) -> @1973 @116 +@1977 := @1970 @1656 +@1979 := @96 @1959 @1919 +@1981 := @143 @1979 @116 +@1982 := (hs : @1925) -> @1981 +@1983 := @1977 @1923 +@1985 := @143 @1684 @116 +@1986 := @221 @1651 +@1988 := @29 (@1639 @36) +@2001 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1988 @38) -> (hs : @225) -> @143 (@96 (@29 (@1639 @151)) @36) @171 +@2002 := @1986 @31 +@2004 := @29 (@1639 @38) +@2016 := {vs : @147} -> + {ts : @148} -> (h : @13 @2004 @31) -> (hs : @225) -> @143 (@96 (@29 (@1639 @153)) @36) @260 +@2017 := @2002 @1684 +@2019 := @29 (@1639 @40) +@2021 := @13 @2019 @31 +@2022 := @1973 @40 +@2024 := @96 @1988 @1964 +@2029 := {ts : @148} -> (h : @2021) -> (hs : @2022) -> @143 @2024 @260 +@2030 := @2017 @116 +@2032 := @96 @2004 @1972 +@2033 := @143 @2032 +@2036 := (h : @1654) -> (hs : @1981) -> @2033 @117 +@2037 := @2030 @1652 +@2039 := @96 @2019 @1979 +@2041 := @143 @2039 @117 +@2042 := (hs : @1985) -> @2041 +@2043 := @2037 @1983 +@2045 := @143 @1686 @117 +@2046 := @656 @841 +@2047 := @628 @841 +@2056 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@2047 @38) @606) -> (hf : @225) -> @657 @1635 +@2057 := @2046 @9 +@2058 := @2047 @9 +@2059 := @598 @2058 +@2060 := @2059 @606 +@2065 := {fs : @147} -> {tys : @148} -> (h : @2060) -> (hf : @225) -> @682 @1635 +@2066 := @2057 @1686 +@2073 := {tys : @148} -> (h : @2060) -> (hf : @2033 @40) -> @13 (@680 @2024) @1635 +@2074 := @2066 @117 +@2080 := (h : @2059 @697) -> (hf : @2041) -> @13 (@680 @2032) @1635 +@2082 := @2074 (@705 @2058) +@2086 := (hf : @2045) -> @13 (@680 @2039) @1635 +@2087 := @2082 @2043 +@2090 := @13 (@680 @1686) @1635 +@2091 := fun (__s : @1632) => @2087 +@2092 := Reasoning.Clinic.Triage.Run +@2094 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__enc_2 @4 +@2095 := @8 @787 +@2098 := (__s : @2092) -> @13 @2094 @2095 +@2099 := Reasoning.Clinic.Triage.Run.state +@2100 := @2099 @4 +@2101 := Reasoning.Clinic.Triage.Run.trace +@2102 := @2101 @4 +@2103 := Reasoning.Clinic.Triage.Run.ledger +@2104 := @2103 @4 +@2105 := @962 @2100 +@2107 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_3 @2100 +@2108 := LexLeanPreservation.encList +@2109 := @2108 @717 +@2110 := @2109 @718 +@2111 := @2110 @2102 +@2112 := LexLeanTarget.TargetSyntax.Ty.list +@2113 := @2112 @721 +@2116 := fun (__x : @717) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_1 @4 +@2117 := Sort 1 +@2118 := (a._@._internal._hyg.#0 : @4) -> @91 +@2119 := @38 @4 +@2122 := (x : @38) -> @154 @2119 @40 +@2123 := @146 @36 +@2126 := @7 @157 @149 @151 +@2129 := @2108 @153 @36 @4 +@2130 := @2126 @2129 +@2131 := @2112 @38 +@2140 := {p : @32} -> + {c : @33} -> + {A : @34} -> {α : @2117} -> {e : @2118} -> {t : @92} -> (h : @2122) -> (xs : @2123) -> @2130 @2131 +@2142 := LexLeanPreservation.Rust.wt_encList @0 +@2156 := {c : @33} -> + {A : @34} -> + {α : @2117} -> + {e : @2118} -> + {t : @92} -> (h : (x : @38) -> @185 @2119 @40) -> (xs : @2123) -> @11 @149 @151 @2129 @2131 +@2157 := @2142 @1 +@2169 := {A : @34} -> + {α : @2117} -> + {e : @2118} -> + {t : @92} -> (h : (x : @38) -> @205 @2119 @40) -> (xs : @2123) -> @12 @151 @2129 @2131 +@2170 := @2157 @2 +@2172 := @13 @2119 @40 +@2180 := {α : @2117} -> + {e : @2118} -> {t : @92} -> (h : (x : @38) -> @2172) -> (xs : @2123) -> @13 @2129 @2131 +@2181 := @2170 @717 +@2182 := (a._@._internal._hyg.#0 : @717) -> @91 +@2183 := (x : @717) -> @2172 +@2184 := @146 @717 +@2192 := {e : @2182} -> {t : @92} -> (h : @2183) -> (xs : @2184) -> @13 (@2109 @36 @4) @2131 +@2193 := @2181 @718 +@2195 := (x : @717) -> @722 @40 +@2197 := @13 (@2110 @4) +@2201 := {t : @92} -> (h : @2195) -> (xs : @2184) -> @2197 @2131 +@2202 := @2193 @721 +@2206 := (h : (x : @717) -> @723) -> (xs : @2184) -> @2197 @2113 +@2208 := @2202 @2116 @2102 +@2210 := @13 @2111 @2113 +@2211 := @1633 @2104 +@2213 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_4 @2104 +@2215 := @96 @2211 @95 +@2217 := @96 @2111 @2215 +@2219 := @96 @2105 @2217 +@2220 := @110 @1635 +@2221 := @2220 @109 +@2222 := @110 @2113 +@2223 := @2222 @2221 +@2224 := @110 @964 +@2225 := @2224 @2223 +@2226 := @221 @2211 +@2228 := @1633 (@2103 @36) +@2241 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @2228 @38) -> (hs : @225) -> @143 (@96 (@1633 (@2103 @151)) @36) @171 +@2242 := @2226 @1635 +@2244 := @1633 (@2103 @38) +@2246 := @13 @2244 @1635 +@2251 := @143 (@96 (@1633 (@2103 @153)) @36) +@2252 := @2220 @38 +@2257 := {vs : @147} -> {ts : @148} -> (h : @2246) -> (hs : @225) -> @2251 @2252 +@2258 := @2242 @95 +@2260 := @1633 (@2103 @40) +@2262 := @13 @2260 @1635 +@2264 := @96 @2228 @95 +@2269 := {ts : @148} -> (h : @2262) -> (hs : @271) -> @143 @2264 @2252 +@2270 := @2258 @109 +@2272 := @13 @2211 @1635 +@2274 := @96 @2244 @95 +@2275 := @143 @2274 +@2278 := (h : @2272) -> (hs : @145) -> @2275 @2221 +@2279 := @2270 @2213 +@2281 := @96 @2260 @95 +@2283 := @143 @2281 @2221 +@2284 := (hs : @145) -> @2283 +@2285 := @2279 @142 +@2287 := @143 @2215 @2221 +@2288 := @221 @2111 +@2290 := @2110 (@2101 @36) +@2303 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @2290 @38) -> (hs : @225) -> @143 (@96 (@2110 (@2101 @151)) @36) @171 +@2304 := @2288 @2113 +@2306 := @2110 (@2101 @38) +@2308 := @13 @2306 @2113 +@2313 := @143 (@96 (@2110 (@2101 @153)) @36) +@2314 := @2222 @38 +@2319 := {vs : @147} -> {ts : @148} -> (h : @2308) -> (hs : @225) -> @2313 @2314 +@2320 := @2304 @2215 +@2322 := @2110 (@2101 @40) +@2324 := @13 @2322 @2113 +@2325 := @2275 @40 +@2327 := @96 @2290 @2264 +@2332 := {ts : @148} -> (h : @2324) -> (hs : @2325) -> @143 @2327 @2314 +@2333 := @2320 @2221 +@2335 := @96 @2306 @2274 +@2336 := @143 @2335 +@2339 := (h : @2210) -> (hs : @2283) -> @2336 @2223 +@2340 := @2333 @2208 +@2342 := @96 @2322 @2281 +@2344 := @143 @2342 @2223 +@2345 := (hs : @2287) -> @2344 +@2346 := @2340 @2285 +@2348 := @143 @2217 @2223 +@2349 := @221 @2105 +@2351 := @962 (@2099 @36) +@2364 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @2351 @38) -> (hs : @225) -> @143 (@96 (@962 (@2099 @151)) @36) @171 +@2365 := @2349 @964 +@2367 := @962 (@2099 @38) +@2369 := @13 @2367 @964 +@2374 := @143 (@96 (@962 (@2099 @153)) @36) +@2375 := @2224 @38 +@2380 := {vs : @147} -> {ts : @148} -> (h : @2369) -> (hs : @225) -> @2374 @2375 +@2381 := @2365 @2217 +@2383 := @962 (@2099 @40) +@2385 := @13 @2383 @964 +@2386 := @2336 @40 +@2388 := @96 @2351 @2327 +@2393 := {ts : @148} -> (h : @2385) -> (hs : @2386) -> @143 @2388 @2375 +@2394 := @2381 @2223 +@2396 := @13 @2105 @964 +@2398 := @96 @2367 @2335 +@2399 := @143 @2398 +@2402 := (h : @2396) -> (hs : @2344) -> @2399 @2225 +@2403 := @2394 @2107 +@2405 := @96 @2383 @2342 +@2407 := @143 @2405 @2225 +@2408 := (hs : @2348) -> @2407 +@2409 := @2403 @2346 +@2411 := @143 @2219 @2225 +@2412 := @656 @787 +@2413 := @628 @787 +@2422 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@2413 @38) @606) -> (hf : @225) -> @657 @2095 +@2423 := @2412 @9 +@2424 := @2413 @9 +@2425 := @598 @2424 +@2426 := @2425 @606 +@2431 := {fs : @147} -> {tys : @148} -> (h : @2426) -> (hf : @225) -> @682 @2095 +@2432 := @2423 @2219 +@2439 := {tys : @148} -> (h : @2426) -> (hf : @2399 @40) -> @13 (@680 @2388) @2095 +@2440 := @2432 @2225 +@2447 := (h : @2425 (@605 @2225)) -> (hf : @2407) -> @13 (@680 @2398) @2095 +@2449 := @2440 (@705 @2424) +@2453 := (hf : @2411) -> @13 (@680 @2405) @2095 +@2454 := @2449 @2409 +@2457 := @13 (@680 @2219) @2095 +@2458 := fun (__s : @2092) => @2454 +@2459 := @29 @149 +@2460 := @64 @149 +@2461 := @13 @2459 +@2462 := @2461 @31 +@2463 := @29 @151 +@2464 := @64 @151 +@2465 := @13 @2463 +@2466 := @2465 @31 +@2467 := @29 @153 +@2468 := @64 @153 +@2469 := @13 @2467 +@2470 := @2469 @31 +@2471 := @29 @36 +@2472 := @64 @36 +@2474 := @13 @2471 @31 +@2475 := @29 @38 +@2476 := @64 @38 +@2478 := @13 @2475 @31 +@2479 := @29 @40 +@2480 := @64 @40 +@2482 := @13 @2479 @31 +@2483 := @96 @2479 +@2484 := @2483 @95 +@2485 := @96 @2475 +@2486 := @2485 @2484 +@2487 := @96 @2471 +@2488 := @2487 @2486 +@2489 := @96 @2467 +@2490 := @2489 @2488 +@2491 := @96 @2463 +@2492 := @2491 @2490 +@2493 := @96 @2459 +@2494 := @2493 @2492 +@2497 := Prod.{0, 0} @35 @91 +@2500 := Prod.mk.{0, 0} @35 @91 +@2501 := @2500 @868 +@2502 := @2501 @2479 +@2503 := @2500 @841 +@2504 := @2503 @2475 +@2505 := @2500 @814 +@2506 := @2505 @2471 +@2507 := @2500 @787 +@2508 := @2507 @2467 +@2509 := @2500 @720 +@2510 := @2509 @2463 +@2511 := @2500 @9 +@2512 := @2511 @2459 +@2513 := @93 @2497 +@2514 := @94 @2497 +@2516 := @2514 @2512 @2513 +@2518 := @2514 @2510 @2516 +@2520 := @2514 @2508 @2518 +@2522 := @2514 @2506 @2520 +@2524 := @2514 @2504 @2522 +@2526 := @2514 @2502 @2524 +@2527 := Bool.true +@2528 := LexLeanTarget.TargetSyntax.Function +@2529 := LexLeanTarget.TargetSyntax.Program.functions +@2530 := @2529 @0 +@2531 := @93 @35 +@2532 := LexLeanTarget.TargetSyntax.Ty.unit +@2533 := LexLeanTarget.TargetSyntax.Value.unit +@2536 := LexLeanTarget.TargetSyntax.Expr.value @2532 @2533 +@2541 := LexLeanTarget.TargetSyntax.Function.mk @2531 @109 @2532 @2536 +@2546 := List.getD.{0} @2528 @2530 @9 @2541 +@2550 := fun (__e_n : @35) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.root @4 @9 +@2551 := @221 @2479 +@2552 := @2469 @38 +@2554 := @143 (@2493 @36) +@2560 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @2552) -> (hs : @225) -> @2554 @171 +@2561 := @2551 @31 +@2568 := {vs : @147} -> {ts : @148} -> (h : @2474) -> (hs : @225) -> @143 (@2491 @36) @260 +@2569 := @2561 @95 +@2570 := @2489 @95 +@2575 := {ts : @148} -> (h : @2478) -> (hs : @271) -> @143 @2570 @260 +@2576 := @2569 @109 +@2577 := @2487 @95 +@2578 := @143 @2577 +@2581 := (h : @2482) -> (hs : @145) -> @2578 @112 +@2582 := @2576 @2480 +@2583 := @2485 @95 +@2585 := @143 @2583 @112 +@2586 := (hs : @145) -> @2585 +@2587 := @2582 @142 +@2589 := @143 @2484 @112 +@2590 := @221 @2475 +@2591 := @2465 @38 +@2592 := @29 @157 +@2593 := @96 @2592 +@2595 := @143 (@2593 @36) +@2601 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @2591) -> (hs : @225) -> @2595 @171 +@2602 := @2590 @31 +@2607 := {vs : @147} -> {ts : @148} -> (h : @2470) -> (hs : @225) -> @2554 @260 +@2608 := @2602 @2484 +@2609 := @2578 @40 +@2610 := @2491 @2570 +@2615 := {ts : @148} -> (h : @2474) -> (hs : @2609) -> @143 @2610 @260 +@2616 := @2608 @112 +@2617 := @2489 @2577 +@2618 := @143 @2617 +@2621 := (h : @2478) -> (hs : @2585) -> @2618 @113 +@2622 := @2616 @2476 +@2623 := @2487 @2583 +@2625 := @143 @2623 @113 +@2626 := (hs : @2589) -> @2625 +@2627 := @2622 @2587 +@2629 := @143 @2486 @113 +@2630 := @221 @2471 +@2631 := @2461 @38 +@2632 := @29 @163 +@2633 := @96 @2632 +@2635 := @143 (@2633 @36) +@2641 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @2631) -> (hs : @225) -> @2635 @171 +@2642 := @2630 @31 +@2647 := {vs : @147} -> {ts : @148} -> (h : @2466) -> (hs : @225) -> @2595 @260 +@2648 := @2642 @2486 +@2649 := @2618 @40 +@2650 := @2493 @2610 +@2655 := {ts : @148} -> (h : @2470) -> (hs : @2649) -> @143 @2650 @260 +@2656 := @2648 @113 +@2657 := @2491 @2617 +@2658 := @143 @2657 +@2661 := (h : @2474) -> (hs : @2625) -> @2658 @114 +@2662 := @2656 @2472 +@2663 := @2489 @2623 +@2665 := @143 @2663 @114 +@2666 := (hs : @2629) -> @2665 +@2667 := @2662 @2627 +@2669 := @143 @2488 @114 +@2670 := @221 @2467 +@2671 := @13 @2592 +@2672 := @2671 @38 +@2673 := #9 +@2674 := @29 @2673 +@2675 := @96 @2674 +@2677 := @143 (@2675 @36) +@2683 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @2672) -> (hs : @225) -> @2677 @171 +@2684 := @2670 @31 +@2689 := {vs : @147} -> {ts : @148} -> (h : @2462) -> (hs : @225) -> @2635 @260 +@2690 := @2684 @2488 +@2691 := @2658 @40 +@2692 := @2593 @2650 +@2697 := {ts : @148} -> (h : @2466) -> (hs : @2691) -> @143 @2692 @260 +@2698 := @2690 @114 +@2699 := @2493 @2657 +@2700 := @143 @2699 +@2703 := (h : @2470) -> (hs : @2665) -> @2700 @115 +@2704 := @2698 @2468 +@2705 := @2491 @2663 +@2707 := @143 @2705 @115 +@2708 := (hs : @2669) -> @2707 +@2709 := @2704 @2667 +@2711 := @143 @2490 @115 +@2712 := @221 @2463 +@2713 := @13 @2632 +@2714 := @2713 @38 +@2715 := #10 +@2716 := @29 @2715 +@2717 := @96 @2716 +@2719 := @143 (@2717 @36) +@2725 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @2714) -> (hs : @225) -> @2719 @171 +@2726 := @2712 @31 +@2727 := @2671 @31 +@2732 := {vs : @147} -> {ts : @148} -> (h : @2727) -> (hs : @225) -> @2677 @260 +@2733 := @2726 @2490 +@2734 := @2700 @40 +@2735 := @2633 @2692 +@2740 := {ts : @148} -> (h : @2462) -> (hs : @2734) -> @143 @2735 @260 +@2741 := @2733 @115 +@2742 := @2593 @2699 +@2743 := @143 @2742 +@2746 := (h : @2466) -> (hs : @2707) -> @2743 @116 +@2747 := @2741 @2464 +@2748 := @2493 @2705 +@2750 := @143 @2748 @116 +@2751 := (hs : @2711) -> @2750 +@2752 := @2747 @2709 +@2754 := @143 @2492 @116 +@2755 := @221 @2459 +@2757 := @13 @2674 @38 +@2758 := #11 +@2759 := @29 @2758 +@2760 := @96 @2759 +@2768 := {t : @92} -> + {vs : @147} -> {ts : @148} -> (h : @2757) -> (hs : @225) -> @143 (@2760 @36) @171 +@2769 := @2755 @31 +@2775 := {vs : @147} -> {ts : @148} -> (h : @2713 @31) -> (hs : @225) -> @2719 @260 +@2776 := @2769 @2492 +@2777 := @2743 @40 +@2778 := @2675 @2735 +@2779 := @143 @2778 +@2783 := {ts : @148} -> (h : @2727) -> (hs : @2777) -> @2779 @260 +@2784 := @2776 @116 +@2785 := @2633 @2742 +@2786 := @143 @2785 +@2789 := (h : @2462) -> (hs : @2750) -> @2786 @117 +@2790 := @2784 @2460 +@2791 := @2593 @2748 +@2792 := @143 @2791 +@2794 := (hs : @2754) -> @2792 @117 +@2795 := @2790 @2752 +@2796 := @143 @2494 +@2797 := @2796 @117 +@2798 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.denote +@2804 := @2798 @149 @151 @153 @36 @38 @40 +@2805 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.__fits_0 +@2811 := @2805 @149 @151 @153 @36 @38 @40 +@2819 := @29 (Reasoning.Main.triageSteps @149 @151 @153 @36 @38 @40) +@2826 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.root @149 @151 @153 @36 @38 @40 +@2827 := Bool +@2828 := Ne.{1} +@2829 := LexLeanPreservation.Obs +@2830 := @2828 @2829 +@2831 := LexLeanPreservation.Rel +@2834 := @2830 (@2831 @40 @4) +@2835 := LexLeanPreservation.Obs.stuck +@2838 := (f : @2827) -> (v : @91) -> @2834 @2835 +@2840 := LexLeanPreservation.Rust.rel_ne_stuck @2811 +@2851 := (v : @91) -> @2830 (@2831 (@2805 @157 @149 @151 @153 @36 @38) @4) @2835 +@2852 := @2840 @2819 +@2856 := @2830 (@2831 @2811 @2819) @2835 +@2857 := @146 @2497 +@2858 := LexLeanPreservation.Rust.FunSem +@2864 := (n : @35) -> @2858 @2673 @163 @157 @4 @149 +@2865 := @596 @2528 +@2866 := @595 @2865 +@2873 := LexLeanRuntime.index (@146 @2528) @2528 (LexLeanRuntime.instIndexableList @2528) +@2877 := @2866 (@2873 (@2529 @2673) @149) +@2878 := @604 @2528 +@2879 := @2878 @151 +@2880 := @2877 @2879 +@2884 := @118 @2715 @2673 @163 @151 +@2885 := LexLeanTarget.TargetSyntax.Function.types +@2886 := @2885 @149 +@2887 := @2884 @2886 +@2888 := @596 @2857 +@2889 := @595 @2888 +@2890 := LexLeanTarget.TargetSemantics.bindAll +@2891 := LexLeanTarget.TargetSyntax.Function.parameters +@2896 := @2889 (@2890 (@2891 @157) @149 @2513) +@2897 := @604 @2857 +@2898 := @2897 @151 +@2899 := @2896 @2898 +@2900 := @596 @2827 +@2901 := @595 @2900 +@2902 := LexLeanPreservation.Rust.fnFallible +@2905 := @2901 (@2902 @2758 @2673) +@2906 := @604 @2827 +@2907 := @2906 @151 +@2908 := @2905 @2907 +@2909 := LexLeanPreservation.RunConv +@2910 := #13 +@2914 := @2909 @2910 @2715 @163 @151 +@2916 := @2830 @149 @2835 +@2917 := Exists.{1} +@2918 := LexLeanPreservation.Rust.ROut +@2919 := @2917 @2918 +@2920 := And +@2921 := LexLeanPreservation.Rust.RealizesFn +@2925 := @2920 (@2921 @2673 @163 @4) +@2926 := LexLeanPreservation.Rust.RCI +@2927 := #15 +@2928 := @2926 @2927 +@2929 := LexLeanPreservation.Rust.fnIdent +@2930 := @2929 @2910 +@2937 := (hne : @2916) -> @2919 (fun (ro : @2918) => @2925 (@2928 @2930 @2758 @4)) +@2952 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {f : @35} -> + {fn : @2528} -> + {args : @147} -> + {env : @2857} -> + {F : @2827} -> + {o : @2829} -> + (hB : @2864) -> + (hfn : @2880) -> (hwt : @2887) -> (hbind : @2899) -> (hF : @2908) -> (hA : @2914) -> @2937 +@2954 := LexLeanPreservation.Rust.compose @0 +@2955 := @2858 @0 +@2960 := (n : @35) -> @2955 @163 @157 @4 @149 +@2961 := @2873 @2530 +@2964 := @2866 (@2961 @149) @2879 +@2968 := @129 @2673 @163 @151 @2886 +@2969 := @2909 @0 +@2972 := @2969 @2715 @163 @151 +@2986 := {c : @33} -> + {A : @34} -> + {f : @35} -> + {fn : @2528} -> + {args : @147} -> + {env : @2857} -> + {F : @2827} -> + {o : @2829} -> + (hB : @2960) -> + (hfn : @2964) -> (hwt : @2968) -> (hbind : @2899) -> (hF : @2908) -> (hA : @2972) -> @2937 +@2987 := @2954 @1 +@2988 := @2955 @1 +@2992 := (n : @35) -> @2988 @157 @4 @149 +@2995 := @137 @163 @151 @2886 +@2996 := @2902 @1 +@2999 := @2901 (@2996 @2673) @2907 +@3000 := @2926 @1 +@3010 := (hbind : @2899) -> + (hF : @2999) -> + (hA : @2972) -> (hne : @2916) -> @2919 (fun (ro : @2918) => @2925 (@3000 @2930 @2758 @4)) +@3020 := {A : @34} -> + {f : @35} -> + {fn : @2528} -> + {args : @147} -> + {env : @2857} -> + {F : @2827} -> {o : @2829} -> (hB : @2992) -> (hfn : @2964) -> (hwt : @2995) -> @3010 +@3021 := @2987 @2 +@3023 := @2988 @2 @4 +@3025 := (n : @35) -> @3023 @149 +@3026 := @143 @151 +@3027 := @3026 @2886 +@3036 := {f : @35} -> + {fn : @2528} -> + {args : @147} -> + {env : @2857} -> + {F : @2827} -> {o : @2829} -> (hB : @3025) -> (hfn : @2964) -> (hwt : @3027) -> @3010 +@3037 := @3021 @9 +@3039 := (n : @35) -> @3023 @9 +@3040 := @2961 @9 +@3041 := @2866 @3040 +@3042 := @3041 @2879 +@3043 := @2996 @9 +@3044 := @2901 @3043 +@3045 := @3044 @2907 +@3046 := @2969 @9 +@3048 := @3046 @163 @151 +@3050 := @3000 (@2929 @9) +@3058 := (hF : @3045) -> + (hA : @3048) -> (hne : @2916) -> @2919 (fun (ro : @2918) => @2925 (@3050 @2758 @4)) +@3067 := {fn : @2528} -> + {args : @147} -> + {env : @2857} -> + {F : @2827} -> + {o : @2829} -> (hB : @3039) -> (hfn : @3042) -> (hwt : @3027) -> (hbind : @2899) -> @3058 +@3068 := @3037 @2546 +@3070 := @3041 (@2878 @2546) +@3071 := @2885 @2546 +@3072 := @3026 @3071 +@3074 := @2890 (@2891 @2546) +@3086 := {args : @147} -> + {env : @2857} -> + {F : @2827} -> + {o : @2829} -> + (hB : @3039) -> + (hfn : @3070) -> (hwt : @3072) -> (hbind : @2889 (@3074 @149 @2513) @2898) -> @3058 +@3087 := @3068 @2494 +@3093 := @2760 (@2717 (@2675 (@2633 (@2593 (@2493 @95))))) +@3095 := @143 @3093 @3071 +@3096 := #12 +@3098 := @96 (@29 @3096) +@3104 := @3098 (@2760 (@2717 (@2675 (@2633 (@2593 @95))))) +@3108 := @2889 (@3074 @3104 @2513) @2898 +@3109 := #14 +@3111 := @96 (@29 @3109) +@3113 := @96 (@29 @2910) +@3119 := @3111 (@3113 (@3098 (@2760 (@2717 (@2675 @95))))) +@3121 := @3046 @3119 @151 +@3124 := @96 (@29 #17) +@3127 := @96 (@29 #16) +@3129 := @96 (@29 @2927) +@3150 := {env : @2857} -> + {F : @2827} -> + {o : @2829} -> + (hB : @3039) -> + (hfn : @3070) -> + (hwt : @3095) -> + (hbind : @3108) -> + (hF : @3045) -> + (hA : @3121) -> + (hne : @2916) -> + @2919 (fun (ro : @2918) => @2925 (@3050 (@3124 (@3127 (@3129 (@3111 (@3113 (@3098 @95)))))) @4)) +@3151 := @3087 @2526 +@3157 := @2717 (@2675 (@2633 (@2593 (@2493 (@2491 @95))))) +@3159 := @143 @3157 @3071 +@3182 := @2889 + (@3074 @3093 @2513) + (@2897 + (@2514 + (@2501 @2459) + (@2514 + (@2503 @2592) + (@2514 + (@2505 @2632) + (@2514 (@2507 @2674) (@2514 (@2509 @2716) (@2514 (@2511 @2759) @2513))))))) +@3188 := @3113 (@3098 (@2760 (@2717 (@2675 (@2633 @95))))) +@3210 := {F : @2827} -> + {o : @2829} -> + (hB : @3039) -> + (hfn : @3070) -> + (hwt : @3159) -> + (hbind : @3182) -> + (hF : @3045) -> + (hA : @3046 @3188 @151) -> + (hne : @2916) -> + @2919 (fun (ro : @2918) => @2925 (@3050 (@3127 (@3129 (@3111 (@3113 (@3098 (@2760 @95)))))) @4)) +@3211 := @3151 @2527 +@3212 := @2779 @3071 +@3235 := @2889 + (@3074 @3157 @2513) + (@2897 + (@2514 + (@2501 @2463) + (@2514 + (@2503 @2459) + (@2514 + (@2505 @2592) + (@2514 (@2507 @2632) (@2514 (@2509 @2674) (@2514 (@2511 @2716) @2513))))))) +@3237 := @3044 (@2906 @2527) +@3239 := @3046 @3104 @151 +@3240 := @2921 @2527 +@3262 := {o : @2829} -> + (hB : @3039) -> + (hfn : @3070) -> + (hwt : @3212) -> + (hbind : @3235) -> + (hF : @3237) -> + (hA : @3239) -> + (hne : @2916) -> + @2919 + (fun (ro : @2918) => + @2920 (@3240 @163 @4) (@3050 (@3129 (@3111 (@3113 (@3098 (@2760 (@2717 @95)))))) @4)) +@3263 := @3211 @2804 +@3264 := @2786 @3071 +@3287 := @2889 + (@3074 @2778 @2513) + (@2897 + (@2514 + (@2501 @2467) + (@2514 + (@2503 @2463) + (@2514 + (@2505 @2459) + (@2514 (@2507 @2592) (@2514 (@2509 @2632) (@2514 (@2511 @2674) @2513))))))) +@3288 := @3046 @3093 +@3294 := @2798 @2758 @2715 @2673 @163 @157 @149 +@3295 := @3288 @3294 +@3301 := @2798 @3096 @2758 @2715 @2673 @163 @157 +@3324 := (hB : @3039) -> + (hfn : @3070) -> + (hwt : @3264) -> + (hbind : @3287) -> + (hF : @3237) -> + (hA : @3295) -> + (hne : @2830 @3301 @2835) -> + @2919 + (fun (ro : @2918) => + @2920 (@3240 (@2798 @3109 @2910 @3096 @2758 @2715 @2673) @4) (@3050 @3119 @4)) +@3325 := @3263 @2550 +@3326 := @2792 @3071 +@3349 := @2889 + (@3074 @2785 @2513) + (@2897 + (@2514 + (@2501 @2471) + (@2514 + (@2503 @2467) + (@2514 + (@2505 @2463) + (@2514 (@2507 @2459) (@2514 (@2509 @2592) (@2514 (@2511 @2632) @2513))))))) +@3350 := @3046 @3157 +@3356 := @2798 @2715 @2673 @163 @157 @149 @151 +@3379 := (hfn : @3070) -> + (hwt : @3326) -> + (hbind : @3349) -> + (hF : @3237) -> + (hA : @3350 @3356) -> + (hne : @2830 @3294 @2835) -> + @2919 + (fun (ro : @2918) => + @2920 (@3240 (@2798 @2910 @3096 @2758 @2715 @2673 @163) @4) (@3050 @3188 @4)) +@3382 := @3325 (@704 @2865 @3040) +@3383 := @2796 @3071 +@3406 := @2889 + (@3074 @2791 @2513) + (@2897 + (@2514 + (@2501 @2475) + (@2514 + (@2503 @2471) + (@2514 + (@2505 @2467) + (@2514 (@2507 @2463) (@2514 (@2509 @2459) (@2514 (@2511 @2592) @2513))))))) +@3407 := @3046 @2778 +@3413 := @2798 @2673 @163 @157 @149 @151 @153 +@3429 := (hwt : @3383) -> + (hbind : @3406) -> + (hF : @3237) -> + (hA : @3407 @3413) -> + (hne : @2830 @3356 @2835) -> @2919 (fun (ro : @2918) => @2920 (@3240 @3301 @4) (@3050 @3104 @4)) +@3430 := @3382 @2795 +@3432 := @3074 @2494 @2513 +@3435 := @2889 @3432 (@2897 @2526) +@3436 := @3046 @2785 +@3442 := @2798 @163 @157 @149 @151 @153 @36 +@3457 := (hbind : @3435) -> + (hF : @3237) -> + (hA : @3436 @3442) -> + (hne : @2830 @3413 @2835) -> @2919 (fun (ro : @2918) => @2920 (@3240 @3294 @4) (@3050 @3093 @4)) +@3460 := @3430 (@704 @2888 @3432) +@3461 := @3046 @2791 +@3467 := @2798 @157 @149 @151 @153 @36 @38 +@3481 := (hF : @3237) -> + (hA : @3461 @3467) -> + (hne : @2830 @3442 @2835) -> @2919 (fun (ro : @2918) => @2920 (@3240 @3356 @4) (@3050 @3157 @4)) +@3484 := @3460 (@704 @2900 @3043) +@3498 := (hA : @3046 @2494 @2804) -> + (hne : @2830 @3467 @2835) -> @2919 (fun (ro : @2918) => @2920 (@3240 @3413 @4) (@3050 @2778 @4)) +@3499 := @3484 @2826 +@3510 := (hne : @2830 @2804 @2835) -> + @2919 (fun (ro : @2918) => @2920 (@3240 @3442 @4) (@3050 @2785 @4)) +@3511 := @3499 @2852 +@3517 := @2920 (@3240 @3467 @4) (@3050 @2791 @4) +@3519 := @2919 (fun (ro : @2918) => @3517) +@3521 := @2919 (fun (__e_ro : @2918) => @3517) +@3530 := LexLeanPreservation.Rust.RepresentableL + (@2491 (@2489 (@2487 (@2485 (@2483 (@96 @42 @95)))))) +@3531 := (__e_hrep : @3530) -> @3521 +@3532 := fun (__e_hrep : @3530) => @3511 +@3533 := (infection : @35) -> @3531 +@3534 := fun (infection : @35) => @3532 +@3535 := (systolic : @35) -> @3533 +@3536 := fun (systolic : @35) => @3534 +@3537 := (whiteCells : @35) -> @3535 +@3538 := fun (whiteCells : @35) => @3536 +@3539 := (respiratoryRate : @35) -> @3537 +@3540 := fun (respiratoryRate : @35) => @3538 +@3541 := (heartRate : @35) -> @3539 +@3542 := fun (heartRate : @35) => @3540 +@3543 := (temperature : @35) -> @3541 +@3544 := fun (temperature : @35) => @3542 +\end{coremodule} +\end{lexlean} diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R3/Compose/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R3/Compose/RustStd.lean deleted file mode 100644 index ee83efb42..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R3/Compose/RustStd.lean +++ /dev/null @@ -1,30 +0,0 @@ -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3 -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Reasoning.Planner.Plan.Step)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.__enc_0 __v) (.adt 0) - | Reasoning.Planner.Plan.Step.FillA => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Planner.Plan.Step.EmptyB => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Planner.Plan.Step.Pour __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - -theorem __wt_2 : ∀ (__s : (Reasoning.Planner.Plan.Node)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.__enc_2 __s) (.adt 2) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_nat) (__s).state) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList __wt_0) (__s).trace) _root_.LexLeanPreservation.Rust.wtl_nil)) - -theorem __wt_3 : ∀ (__s : (Reasoning.Planner.Plan.Ledger)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.__enc_3 __s) (.adt 3) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).iterations) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).attempts) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).firings) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).expansions) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).verifications) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).frontier) _root_.LexLeanPreservation.Rust.wtl_nil)))))) - -theorem __wt_1 : ∀ (__s : (Reasoning.Planner.Plan.Search)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.__enc_1 __s) (.adt 1) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList __wt_2) (__s).frontier) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_nat)) (__s).visited) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encOption (_root_.LexLeanPreservation.Rust.wt_encPair (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_nat) __wt_2)) (__s).found) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_bool (__s).truncated) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_3 (__s).ledger) _root_.LexLeanPreservation.Rust.wtl_nil))))) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (target : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat target)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.denote target) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat target)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat target) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.root target) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R3/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R3/Compose/RustStd.lex.tex new file mode 100644 index 000000000..d8f613580 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R3/Compose/RustStd.lex.tex @@ -0,0 +1,1301 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3, + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_0 : @16 := @424 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_2 : @431 := @905 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_3 : @913 := @1372 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_3], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_1 : @1379 := @2024 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.root : @2637 := @2638 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.program +@1 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.krate +@2 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.flags +@3 := Reasoning.Planner.Plan.Step +@4 := #0 +@5 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@14 := @13 @6 +@15 := @14 @10 +@16 := (__v : @3) -> @15 +@17 := fun (__v : @3) => @15 +@18 := LexLeanTarget.TargetSyntax.Value +@19 := LexLeanTarget.TargetSyntax.Ty +@20 := List.nil.{0} +@21 := List.cons.{0} +@22 := @20 @18 +@23 := @20 @19 +@24 := LexLeanTarget.TargetSyntax.Program +@25 := LexLeanPreservation.Rust.RCrate +@26 := LexLeanPreservation.Rust.Flags +@27 := LexLeanPreservation.Rust.WTL +@28 := #2 +@29 := @27 @28 +@30 := #1 +@37 := {p : @24} -> {c : @25} -> {A : @26} -> @29 @30 @4 @22 @23 +@39 := LexLeanPreservation.Rust.wtl_nil @0 +@40 := @27 @0 +@46 := {c : @25} -> {A : @26} -> @40 @30 @4 @22 @23 +@47 := @39 @1 +@48 := @40 @1 +@52 := {A : @26} -> @48 @4 @22 @23 +@53 := @47 @2 +@54 := @48 @2 +@55 := @54 @22 +@56 := @55 @23 +@57 := Nat +@58 := List.{0} +@59 := @58 @18 +@60 := @58 @19 +@61 := Eq.{1} +@62 := Option.{0} +@63 := @62 @60 +@64 := @61 @63 +@65 := LexLeanPreservation.Rust.adtFields +@66 := #6 +@67 := @65 @66 +@68 := #3 +@71 := @64 (@67 @68 @28) +@72 := Option.some.{0} +@73 := @72 @60 +@74 := @73 @4 +@75 := @71 @74 +@76 := #7 +@78 := @27 @76 @66 +@79 := #5 +@82 := @78 @79 @28 @30 +@83 := #8 +@86 := @7 @83 @76 @66 +@87 := LexLeanTarget.TargetSyntax.Value.adt +@88 := #4 +@90 := @87 @88 @68 +@91 := @86 @90 +@92 := @8 @79 +@102 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {i : @57} -> {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @75) -> (hf : @82) -> @91 @92 +@104 := LexLeanPreservation.Rust.wt_adt @0 +@105 := @65 @0 +@109 := @64 (@105 @68 @28) @74 +@113 := @40 @66 @79 @28 @30 +@125 := {c : @25} -> + {A : @26} -> + {i : @57} -> + {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @113) -> @11 @76 @66 @90 @92 +@126 := @104 @1 +@129 := @48 @79 @28 @30 +@139 := {A : @26} -> + {i : @57} -> + {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @129) -> @12 @66 @90 @92 +@140 := @126 @2 +@142 := @54 @28 @30 +@143 := @13 @90 +@150 := {i : @57} -> {k : @57} -> {fs : @59} -> {tys : @60} -> (h : @109) -> (hf : @142) -> @143 @92 +@151 := @140 @9 +@152 := @105 @9 +@161 := {k : @57} -> + {fs : @59} -> {tys : @60} -> (h : @64 (@152 @28) @74) -> (hf : @142) -> @143 @10 +@162 := @151 @9 +@163 := @152 @9 +@164 := @64 @163 +@165 := @164 @74 +@166 := @87 @9 +@168 := @13 (@166 @68) +@173 := {fs : @59} -> {tys : @60} -> (h : @165) -> (hf : @142) -> @168 @10 +@174 := @162 @22 +@175 := @55 @30 +@178 := @13 (@166 @22) @10 +@181 := {tys : @60} -> (h : @165) -> (hf : @175) -> @178 +@182 := @174 @23 +@183 := @73 @23 +@186 := (h : @164 @183) -> (hf : @56) -> @178 +@187 := Eq.refl.{1} +@188 := @187 @63 +@191 := @182 (@188 @163) @53 +@192 := 1 +@193 := @151 @192 +@194 := @152 @192 +@195 := @64 @194 +@196 := @195 @74 +@197 := @87 @192 +@204 := {fs : @59} -> {tys : @60} -> (h : @196) -> (hf : @142) -> @13 (@197 @68) @10 +@205 := @193 @22 +@208 := @13 (@197 @22) @10 +@211 := {tys : @60} -> (h : @196) -> (hf : @175) -> @208 +@212 := @205 @23 +@215 := (h : @195 @183) -> (hf : @56) -> @208 +@218 := @212 (@188 @194) @53 +@219 := LexLeanTarget.TargetSyntax.Value.nat +@220 := @219 @4 +@221 := LexLeanTarget.TargetSyntax.Ty.nat +@224 := @7 @68 @28 @30 +@230 := {p : @24} -> {c : @25} -> {A : @26} -> (n : @57) -> @224 @220 @221 +@232 := LexLeanPreservation.Rust.wt_nat @0 +@234 := @11 @28 @30 +@239 := {c : @25} -> {A : @26} -> (n : @57) -> @234 @220 @221 +@240 := @232 @1 +@241 := @12 @30 +@245 := {A : @26} -> (n : @57) -> @241 @220 @221 +@246 := @240 @2 +@247 := @13 @220 +@248 := @247 @221 +@249 := (n : @57) -> @248 +@250 := @246 @4 +@251 := @21 @18 +@253 := @251 @220 @22 +@254 := @21 @19 +@255 := @254 @221 +@256 := @255 @23 +@259 := @7 @66 @79 @88 +@261 := @259 @68 @28 +@264 := @27 @83 @76 @66 +@266 := @251 @79 @68 +@267 := @264 @266 +@269 := @254 @88 @28 +@279 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {v : @18} -> {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @261) -> (hs : @82) -> @267 @269 +@281 := LexLeanPreservation.Rust.wtl_cons @0 +@283 := @11 @79 @88 +@297 := {c : @25} -> + {A : @26} -> + {v : @18} -> + {t : @19} -> + {vs : @59} -> {ts : @60} -> (h : @283 @68 @28) -> (hs : @113) -> @40 @76 @66 @266 @269 +@298 := @281 @1 +@299 := @12 @88 +@311 := {A : @26} -> + {v : @18} -> + {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @299 @68 @28) -> (hs : @129) -> @48 @66 @266 @269 +@312 := @298 @2 +@322 := {v : @18} -> + {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @13 @68 @28) -> (hs : @142) -> @54 @266 @269 +@323 := @312 @220 +@324 := @219 @68 +@325 := @13 @324 +@326 := @325 @28 +@327 := @219 @79 +@328 := @251 @327 +@330 := @54 (@328 @68) +@336 := {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @326) -> (hs : @142) -> @330 @269 +@337 := @323 @221 +@338 := @219 @28 +@340 := @13 @338 @221 +@341 := @219 @88 +@342 := @251 @341 +@344 := @54 (@342 @68) +@345 := @255 @28 +@350 := {vs : @59} -> {ts : @60} -> (h : @340) -> (hs : @142) -> @344 @345 +@351 := @337 @22 +@352 := @219 @30 +@354 := @13 @352 @221 +@356 := @251 @324 @22 +@357 := @54 @356 +@361 := {ts : @60} -> (h : @354) -> (hs : @175) -> @357 @345 +@362 := @351 @23 +@364 := @251 @338 @22 +@365 := @54 @364 +@368 := (h : @248) -> (hs : @56) -> @365 @256 +@369 := @362 @250 +@371 := @251 @352 @22 +@372 := @54 @371 +@373 := @372 @256 +@374 := (hs : @56) -> @373 +@375 := @369 @53 +@377 := @54 @253 @256 +@378 := 2 +@379 := @151 @378 +@380 := @152 @378 +@381 := @64 @380 +@382 := @381 @74 +@383 := @87 @378 +@390 := {fs : @59} -> {tys : @60} -> (h : @382) -> (hf : @142) -> @13 (@383 @68) @10 +@391 := @379 @253 +@398 := {tys : @60} -> (h : @382) -> (hf : @365 @30) -> @13 (@383 @356) @10 +@399 := @391 @256 +@406 := (h : @381 (@73 @256)) -> (hf : @373) -> @13 (@383 @364) @10 +@408 := @399 (@188 @380) +@412 := (hf : @377) -> @13 (@383 @371) @10 +@413 := @408 @375 +@416 := @13 (@383 @253) @10 +@417 := fun (__x0 : @57) => @413 +@424 := fun (__v : @3) => Reasoning.Planner.Plan.Step.casesOn.{0} @17 @4 @191 @218 @417 +@425 := Reasoning.Planner.Plan.Node +@426 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.__enc_2 +@427 := @426 @4 +@428 := @8 @378 +@429 := @13 @427 +@430 := @429 @428 +@431 := (__s : @425) -> @430 +@432 := Reasoning.Planner.Plan.Node.state +@433 := @432 @4 +@434 := Reasoning.Planner.Plan.Node.trace +@435 := @434 @4 +@436 := LexLeanPreservation.encPair +@437 := @436 @57 +@438 := @437 @57 +@439 := @438 @219 +@440 := @439 @219 +@441 := @440 @433 +@442 := LexLeanTarget.TargetSyntax.Ty.pair +@443 := @442 @221 +@444 := @443 @221 +@445 := fun (__x : @57) => @250 +@446 := Sort 1 +@447 := (a._@._internal._hyg.#0 : @30) -> @18 +@448 := #9 +@451 := @7 @448 @83 @76 +@452 := @88 @4 +@455 := (x : @79) -> @451 @452 @28 +@456 := #10 +@462 := (x : @79) -> @7 @456 @448 @83 @452 @28 +@463 := Prod.{0, 0} +@465 := @463 @76 @66 +@466 := #11 +@469 := @7 @466 @456 @448 +@474 := @436 @83 @76 @66 @79 @4 +@475 := @469 @474 +@477 := @442 @88 @68 +@490 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {α : @446} -> + {β : @446} -> + {ea : @447} -> + {eb : @447} -> {s : @19} -> {t : @19} -> (ha : @455) -> (hb : @462) -> (x : @465) -> @475 @477 +@492 := LexLeanPreservation.Rust.wt_encPair @0 +@517 := {c : @25} -> + {A : @26} -> + {α : @446} -> + {β : @446} -> + {ea : @447} -> + {eb : @447} -> + {s : @19} -> + {t : @19} -> + (ha : (x : @79) -> @11 @83 @76 @452 @28) -> + (hb : (x : @79) -> @11 @448 @83 @452 @28) -> (x : @465) -> @11 @456 @448 @474 @477 +@518 := @492 @1 +@539 := {A : @26} -> + {α : @446} -> + {β : @446} -> + {ea : @447} -> + {eb : @447} -> + {s : @19} -> + {t : @19} -> + (ha : (x : @79) -> @12 @76 @452 @28) -> + (hb : (x : @79) -> @12 @83 @452 @28) -> (x : @465) -> @12 @448 @474 @477 +@540 := @518 @2 +@542 := @13 @452 @28 +@543 := (x : @79) -> @542 +@554 := {α : @446} -> + {β : @446} -> + {ea : @447} -> + {eb : @447} -> {s : @19} -> {t : @19} -> (ha : @543) -> (hb : @543) -> (x : @465) -> @13 @474 @477 +@555 := @540 @57 +@556 := (a._@._internal._hyg.#0 : @57) -> @18 +@557 := (x : @57) -> @542 +@558 := @463 @57 +@573 := {β : @446} -> + {ea : @556} -> + {eb : @447} -> + {s : @19} -> + {t : @19} -> (ha : @557) -> (hb : @543) -> (x : @558 @66) -> @13 (@437 @76 @66 @79 @4) @477 +@574 := @555 @57 +@575 := @558 @57 +@587 := {ea : @556} -> + {eb : @556} -> + {s : @19} -> {t : @19} -> (ha : @557) -> (hb : @557) -> (x : @575) -> @13 (@438 @66 @79 @4) @477 +@588 := @574 @219 +@590 := (x : @57) -> @247 @28 +@600 := {eb : @556} -> + {s : @19} -> {t : @19} -> (ha : @590) -> (hb : @557) -> (x : @575) -> @13 (@439 @79 @4) @477 +@601 := @588 @219 +@603 := @13 (@440 @4) +@609 := {s : @19} -> {t : @19} -> (ha : @590) -> (hb : @590) -> (x : @575) -> @603 @477 +@610 := @601 @221 +@611 := (x : @57) -> @248 +@617 := {t : @19} -> (ha : @611) -> (hb : @590) -> (x : @575) -> @603 (@443 @68) +@618 := @610 @221 +@620 := (x : @575) -> @603 @444 +@622 := (ha : @611) -> (hb : @611) -> @620 +@624 := @618 @445 @445 +@625 := @624 @433 +@627 := @13 @441 @444 +@628 := LexLeanPreservation.encList +@629 := @628 @3 +@630 := @629 @5 +@631 := @630 @435 +@632 := LexLeanTarget.TargetSyntax.Ty.list +@633 := @632 @10 +@636 := fun (__x : @3) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_0 @4 +@637 := (a._@._internal._hyg.#0 : @4) -> @18 +@638 := @28 @4 +@641 := (x : @28) -> @259 @638 @30 +@642 := @58 @68 +@645 := @7 @76 @66 @79 +@648 := @628 @88 @68 @4 +@649 := @645 @648 +@650 := @632 @28 +@659 := {p : @24} -> + {c : @25} -> + {A : @26} -> {α : @446} -> {e : @637} -> {t : @19} -> (h : @641) -> (xs : @642) -> @649 @650 +@661 := LexLeanPreservation.Rust.wt_encList @0 +@664 := (x : @28) -> @283 @638 @30 +@666 := @11 @66 @79 +@675 := {c : @25} -> + {A : @26} -> {α : @446} -> {e : @637} -> {t : @19} -> (h : @664) -> (xs : @642) -> @666 @648 @650 +@676 := @661 @1 +@679 := (x : @28) -> @299 @638 @30 +@680 := @12 @79 +@688 := {A : @26} -> + {α : @446} -> {e : @637} -> {t : @19} -> (h : @679) -> (xs : @642) -> @680 @648 @650 +@689 := @676 @2 +@691 := @13 @638 @30 +@692 := (x : @28) -> @691 +@699 := {α : @446} -> {e : @637} -> {t : @19} -> (h : @692) -> (xs : @642) -> @13 @648 @650 +@700 := @689 @3 +@701 := (a._@._internal._hyg.#0 : @3) -> @18 +@702 := (x : @3) -> @691 +@703 := @58 @3 +@711 := {e : @701} -> {t : @19} -> (h : @702) -> (xs : @703) -> @13 (@629 @68 @4) @650 +@712 := @700 @5 +@714 := (x : @3) -> @14 @30 +@716 := @13 (@630 @4) +@720 := {t : @19} -> (h : @714) -> (xs : @703) -> @716 @650 +@721 := @712 @10 +@725 := (h : (x : @3) -> @15) -> (xs : @703) -> @716 @633 +@727 := @721 @636 @435 +@729 := @13 @631 @633 +@731 := @251 @631 @22 +@733 := @251 @441 @731 +@734 := @254 @633 +@735 := @734 @23 +@736 := @254 @444 +@737 := @736 @735 +@738 := @312 @631 +@740 := @630 (@434 @68) +@753 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @740 @28) -> (hs : @142) -> @54 (@251 (@630 (@434 @79)) @68) @269 +@754 := @738 @633 +@756 := @630 (@434 @28) +@758 := @13 @756 @633 +@763 := @54 (@251 (@630 (@434 @88)) @68) +@764 := @734 @28 +@769 := {vs : @59} -> {ts : @60} -> (h : @758) -> (hs : @142) -> @763 @764 +@770 := @754 @22 +@772 := @630 (@434 @30) +@774 := @13 @772 @633 +@776 := @251 @740 @22 +@781 := {ts : @60} -> (h : @774) -> (hs : @175) -> @54 @776 @764 +@782 := @770 @23 +@784 := @251 @756 @22 +@785 := @54 @784 +@788 := (h : @729) -> (hs : @56) -> @785 @735 +@789 := @782 @727 +@791 := @251 @772 @22 +@793 := @54 @791 @735 +@794 := (hs : @56) -> @793 +@795 := @789 @53 +@797 := @54 @731 @735 +@798 := @312 @441 +@800 := @440 (@432 @68) +@813 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @800 @28) -> (hs : @142) -> @54 (@251 (@440 (@432 @79)) @68) @269 +@814 := @798 @444 +@816 := @440 (@432 @28) +@818 := @13 @816 @444 +@823 := @54 (@251 (@440 (@432 @88)) @68) +@824 := @736 @28 +@829 := {vs : @59} -> {ts : @60} -> (h : @818) -> (hs : @142) -> @823 @824 +@830 := @814 @731 +@832 := @440 (@432 @30) +@834 := @13 @832 @444 +@835 := @785 @30 +@837 := @251 @800 @776 +@842 := {ts : @60} -> (h : @834) -> (hs : @835) -> @54 @837 @824 +@843 := @830 @735 +@845 := @251 @816 @784 +@846 := @54 @845 +@849 := (h : @627) -> (hs : @793) -> @846 @737 +@850 := @843 @625 +@852 := @251 @832 @791 +@854 := @54 @852 @737 +@855 := (hs : @797) -> @854 +@856 := @850 @795 +@858 := @54 @733 @737 +@859 := @140 @378 +@860 := @105 @378 +@869 := {k : @57} -> + {fs : @59} -> {tys : @60} -> (h : @64 (@860 @28) @74) -> (hf : @142) -> @143 @428 +@870 := @859 @9 +@871 := @860 @9 +@872 := @64 @871 +@873 := @872 @74 +@878 := {fs : @59} -> {tys : @60} -> (h : @873) -> (hf : @142) -> @168 @428 +@879 := @870 @733 +@886 := {tys : @60} -> (h : @873) -> (hf : @846 @30) -> @13 (@166 @837) @428 +@887 := @879 @737 +@894 := (h : @872 (@73 @737)) -> (hf : @854) -> @13 (@166 @845) @428 +@896 := @887 (@188 @871) +@900 := (hf : @858) -> @13 (@166 @852) @428 +@901 := @896 @856 +@904 := @13 (@166 @733) @428 +@905 := fun (__s : @425) => @901 +@906 := Reasoning.Planner.Plan.Ledger +@907 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.__enc_3 +@908 := @907 @4 +@909 := 3 +@910 := @8 @909 +@913 := (__s : @906) -> @13 @908 @910 +@914 := Reasoning.Planner.Plan.Ledger.iterations +@915 := @914 @4 +@916 := Reasoning.Planner.Plan.Ledger.attempts +@917 := @916 @4 +@918 := Reasoning.Planner.Plan.Ledger.firings +@919 := @918 @4 +@920 := Reasoning.Planner.Plan.Ledger.expansions +@921 := @920 @4 +@922 := Reasoning.Planner.Plan.Ledger.verifications +@923 := @922 @4 +@924 := Reasoning.Planner.Plan.Ledger.frontier +@925 := @924 @4 +@926 := @219 @915 +@927 := @246 @915 +@929 := @13 @926 @221 +@930 := @219 @917 +@931 := @246 @917 +@933 := @13 @930 @221 +@934 := @219 @919 +@935 := @246 @919 +@937 := @13 @934 @221 +@938 := @219 @921 +@939 := @246 @921 +@941 := @13 @938 @221 +@942 := @219 @923 +@943 := @246 @923 +@945 := @13 @942 @221 +@946 := @219 @925 +@947 := @246 @925 +@949 := @13 @946 @221 +@951 := @251 @946 @22 +@953 := @251 @942 @951 +@955 := @251 @938 @953 +@957 := @251 @934 @955 +@959 := @251 @930 @957 +@961 := @251 @926 @959 +@962 := @255 @256 +@963 := @255 @962 +@964 := @255 @963 +@965 := @255 @964 +@966 := @255 @965 +@967 := @312 @946 +@969 := @219 (@924 @68) +@982 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @969 @28) -> (hs : @142) -> @54 (@251 (@219 (@924 @79)) @68) @269 +@983 := @967 @221 +@985 := @219 (@924 @28) +@997 := {vs : @59} -> + {ts : @60} -> (h : @13 @985 @221) -> (hs : @142) -> @54 (@251 (@219 (@924 @88)) @68) @345 +@998 := @983 @22 +@1000 := @219 (@924 @30) +@1002 := @13 @1000 @221 +@1004 := @251 @969 @22 +@1009 := {ts : @60} -> (h : @1002) -> (hs : @175) -> @54 @1004 @345 +@1010 := @998 @23 +@1012 := @251 @985 @22 +@1013 := @54 @1012 +@1016 := (h : @949) -> (hs : @56) -> @1013 @256 +@1017 := @1010 @947 +@1019 := @251 @1000 @22 +@1021 := @54 @1019 @256 +@1022 := (hs : @56) -> @1021 +@1023 := @1017 @53 +@1025 := @54 @951 @256 +@1026 := @312 @942 +@1028 := @219 (@922 @68) +@1041 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @1028 @28) -> (hs : @142) -> @54 (@251 (@219 (@922 @79)) @68) @269 +@1042 := @1026 @221 +@1044 := @219 (@922 @28) +@1056 := {vs : @59} -> + {ts : @60} -> (h : @13 @1044 @221) -> (hs : @142) -> @54 (@251 (@219 (@922 @88)) @68) @345 +@1057 := @1042 @951 +@1059 := @219 (@922 @30) +@1061 := @13 @1059 @221 +@1062 := @1013 @30 +@1064 := @251 @1028 @1004 +@1069 := {ts : @60} -> (h : @1061) -> (hs : @1062) -> @54 @1064 @345 +@1070 := @1057 @256 +@1072 := @251 @1044 @1012 +@1073 := @54 @1072 +@1076 := (h : @945) -> (hs : @1021) -> @1073 @962 +@1077 := @1070 @943 +@1079 := @251 @1059 @1019 +@1081 := @54 @1079 @962 +@1082 := (hs : @1025) -> @1081 +@1083 := @1077 @1023 +@1085 := @54 @953 @962 +@1086 := @312 @938 +@1088 := @219 (@920 @68) +@1101 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @1088 @28) -> (hs : @142) -> @54 (@251 (@219 (@920 @79)) @68) @269 +@1102 := @1086 @221 +@1104 := @219 (@920 @28) +@1116 := {vs : @59} -> + {ts : @60} -> (h : @13 @1104 @221) -> (hs : @142) -> @54 (@251 (@219 (@920 @88)) @68) @345 +@1117 := @1102 @953 +@1119 := @219 (@920 @30) +@1121 := @13 @1119 @221 +@1122 := @1073 @30 +@1124 := @251 @1088 @1064 +@1129 := {ts : @60} -> (h : @1121) -> (hs : @1122) -> @54 @1124 @345 +@1130 := @1117 @962 +@1132 := @251 @1104 @1072 +@1133 := @54 @1132 +@1136 := (h : @941) -> (hs : @1081) -> @1133 @963 +@1137 := @1130 @939 +@1139 := @251 @1119 @1079 +@1141 := @54 @1139 @963 +@1142 := (hs : @1085) -> @1141 +@1143 := @1137 @1083 +@1145 := @54 @955 @963 +@1146 := @312 @934 +@1148 := @219 (@918 @68) +@1161 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @1148 @28) -> (hs : @142) -> @54 (@251 (@219 (@918 @79)) @68) @269 +@1162 := @1146 @221 +@1164 := @219 (@918 @28) +@1176 := {vs : @59} -> + {ts : @60} -> (h : @13 @1164 @221) -> (hs : @142) -> @54 (@251 (@219 (@918 @88)) @68) @345 +@1177 := @1162 @955 +@1179 := @219 (@918 @30) +@1181 := @13 @1179 @221 +@1182 := @1133 @30 +@1184 := @251 @1148 @1124 +@1189 := {ts : @60} -> (h : @1181) -> (hs : @1182) -> @54 @1184 @345 +@1190 := @1177 @963 +@1192 := @251 @1164 @1132 +@1193 := @54 @1192 +@1196 := (h : @937) -> (hs : @1141) -> @1193 @964 +@1197 := @1190 @935 +@1199 := @251 @1179 @1139 +@1201 := @54 @1199 @964 +@1202 := (hs : @1145) -> @1201 +@1203 := @1197 @1143 +@1205 := @54 @957 @964 +@1206 := @312 @930 +@1208 := @219 (@916 @68) +@1221 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @1208 @28) -> (hs : @142) -> @54 (@251 (@219 (@916 @79)) @68) @269 +@1222 := @1206 @221 +@1224 := @219 (@916 @28) +@1236 := {vs : @59} -> + {ts : @60} -> (h : @13 @1224 @221) -> (hs : @142) -> @54 (@251 (@219 (@916 @88)) @68) @345 +@1237 := @1222 @957 +@1239 := @219 (@916 @30) +@1241 := @13 @1239 @221 +@1242 := @1193 @30 +@1244 := @251 @1208 @1184 +@1249 := {ts : @60} -> (h : @1241) -> (hs : @1242) -> @54 @1244 @345 +@1250 := @1237 @964 +@1252 := @251 @1224 @1192 +@1253 := @54 @1252 +@1256 := (h : @933) -> (hs : @1201) -> @1253 @965 +@1257 := @1250 @931 +@1259 := @251 @1239 @1199 +@1261 := @54 @1259 @965 +@1262 := (hs : @1205) -> @1261 +@1263 := @1257 @1203 +@1265 := @54 @959 @965 +@1266 := @312 @926 +@1268 := @219 (@914 @68) +@1281 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @1268 @28) -> (hs : @142) -> @54 (@251 (@219 (@914 @79)) @68) @269 +@1282 := @1266 @221 +@1284 := @219 (@914 @28) +@1296 := {vs : @59} -> + {ts : @60} -> (h : @13 @1284 @221) -> (hs : @142) -> @54 (@251 (@219 (@914 @88)) @68) @345 +@1297 := @1282 @959 +@1299 := @219 (@914 @30) +@1301 := @13 @1299 @221 +@1302 := @1253 @30 +@1304 := @251 @1268 @1244 +@1309 := {ts : @60} -> (h : @1301) -> (hs : @1302) -> @54 @1304 @345 +@1310 := @1297 @965 +@1312 := @251 @1284 @1252 +@1313 := @54 @1312 +@1316 := (h : @929) -> (hs : @1261) -> @1313 @966 +@1317 := @1310 @927 +@1319 := @251 @1299 @1259 +@1321 := @54 @1319 @966 +@1322 := (hs : @1265) -> @1321 +@1323 := @1317 @1263 +@1325 := @54 @961 @966 +@1326 := @140 @909 +@1327 := @105 @909 +@1336 := {k : @57} -> + {fs : @59} -> {tys : @60} -> (h : @64 (@1327 @28) @74) -> (hf : @142) -> @143 @910 +@1337 := @1326 @9 +@1338 := @1327 @9 +@1339 := @64 @1338 +@1340 := @1339 @74 +@1345 := {fs : @59} -> {tys : @60} -> (h : @1340) -> (hf : @142) -> @168 @910 +@1346 := @1337 @961 +@1353 := {tys : @60} -> (h : @1340) -> (hf : @1313 @30) -> @13 (@166 @1304) @910 +@1354 := @1346 @966 +@1361 := (h : @1339 (@73 @966)) -> (hf : @1321) -> @13 (@166 @1312) @910 +@1363 := @1354 (@188 @1338) +@1367 := (hf : @1325) -> @13 (@166 @1319) @910 +@1368 := @1363 @1323 +@1371 := @13 (@166 @961) @910 +@1372 := fun (__s : @906) => @1368 +@1373 := Reasoning.Planner.Plan.Search +@1375 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.__enc_1 @4 +@1376 := @8 @192 +@1379 := (__s : @1373) -> @13 @1375 @1376 +@1380 := Reasoning.Planner.Plan.Search.frontier +@1381 := @1380 @4 +@1382 := Reasoning.Planner.Plan.Search.visited +@1383 := @1382 @4 +@1384 := Reasoning.Planner.Plan.Search.found +@1385 := @1384 @4 +@1386 := Reasoning.Planner.Plan.Search.truncated +@1387 := @1386 @4 +@1388 := Reasoning.Planner.Plan.Search.ledger +@1389 := @1388 @4 +@1390 := @628 @425 +@1391 := @1390 @426 +@1392 := @1391 @1381 +@1393 := @632 @428 +@1396 := fun (__x : @425) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_2 @4 +@1397 := @689 @425 +@1398 := (a._@._internal._hyg.#0 : @425) -> @18 +@1399 := (x : @425) -> @691 +@1400 := @58 @425 +@1408 := {e : @1398} -> {t : @19} -> (h : @1399) -> (xs : @1400) -> @13 (@1390 @68 @4) @650 +@1409 := @1397 @426 +@1411 := (x : @425) -> @429 @30 +@1413 := @13 (@1391 @4) +@1417 := {t : @19} -> (h : @1411) -> (xs : @1400) -> @1413 @650 +@1418 := @1409 @428 +@1419 := (x : @425) -> @430 +@1422 := (h : @1419) -> (xs : @1400) -> @1413 @1393 +@1424 := @1418 @1396 @1381 +@1426 := @13 @1392 @1393 +@1427 := @628 @575 +@1428 := @1427 @440 +@1429 := @1428 @1383 +@1430 := @632 @444 +@1432 := fun (__x : @575) => @624 @4 +@1433 := @689 @575 +@1434 := (a._@._internal._hyg.#0 : @575) -> @18 +@1435 := (x : @575) -> @691 +@1436 := @58 @575 +@1444 := {e : @1434} -> {t : @19} -> (h : @1435) -> (xs : @1436) -> @13 (@1427 @68 @4) @650 +@1445 := @1433 @440 +@1447 := (x : @575) -> @603 @30 +@1449 := @13 (@1428 @4) +@1453 := {t : @19} -> (h : @1447) -> (xs : @1436) -> @1449 @650 +@1454 := @1445 @444 +@1457 := (h : @620) -> (xs : @1436) -> @1449 @1430 +@1459 := @1454 @1432 @1383 +@1461 := @13 @1429 @1430 +@1462 := @463 @575 +@1463 := @1462 @425 +@1464 := @436 @575 +@1465 := @1464 @425 +@1466 := @1465 @440 +@1467 := @1466 @426 +@1468 := LexLeanPreservation.encOption +@1469 := @1468 @1463 +@1470 := @1469 @1467 +@1471 := @1470 @1385 +@1472 := @442 @444 +@1473 := @1472 @428 +@1474 := LexLeanTarget.TargetSyntax.Ty.option +@1475 := @1474 @1473 +@1476 := @540 @575 +@1477 := (x : @575) -> @542 +@1492 := {β : @446} -> + {ea : @1434} -> + {eb : @447} -> + {s : @19} -> + {t : @19} -> (ha : @1477) -> (hb : @543) -> (x : @1462 @66) -> @13 (@1464 @76 @66 @79 @4) @477 +@1493 := @1476 @425 +@1494 := (x : @425) -> @542 +@1506 := {ea : @1434} -> + {eb : @1398} -> + {s : @19} -> + {t : @19} -> (ha : @1477) -> (hb : @1494) -> (x : @1463) -> @13 (@1465 @66 @79 @4) @477 +@1507 := @1493 @440 +@1509 := (x : @575) -> @603 @28 +@1519 := {eb : @1398} -> + {s : @19} -> {t : @19} -> (ha : @1509) -> (hb : @1494) -> (x : @1463) -> @13 (@1466 @79 @4) @477 +@1520 := @1507 @426 +@1522 := (x : @425) -> @429 @28 +@1524 := @13 (@1467 @4) +@1530 := {s : @19} -> {t : @19} -> (ha : @1509) -> (hb : @1522) -> (x : @1463) -> @1524 @477 +@1531 := @1520 @444 +@1537 := {t : @19} -> (ha : @620) -> (hb : @1522) -> (x : @1463) -> @1524 (@1472 @68) +@1538 := @1531 @428 +@1540 := (x : @1463) -> @1524 @1473 +@1542 := (ha : @620) -> (hb : @1419) -> @1540 +@1546 := fun (__x : @1463) => @1538 @1432 @1396 @4 +@1547 := @62 @68 +@1550 := @1468 @88 @68 @4 +@1551 := @645 @1550 +@1552 := @1474 @28 +@1561 := {p : @24} -> + {c : @25} -> + {A : @26} -> {α : @446} -> {e : @637} -> {t : @19} -> (h : @641) -> (o : @1547) -> @1551 @1552 +@1563 := LexLeanPreservation.Rust.wt_encOption @0 +@1572 := {c : @25} -> + {A : @26} -> + {α : @446} -> {e : @637} -> {t : @19} -> (h : @664) -> (o : @1547) -> @666 @1550 @1552 +@1573 := @1563 @1 +@1581 := {A : @26} -> + {α : @446} -> {e : @637} -> {t : @19} -> (h : @679) -> (o : @1547) -> @680 @1550 @1552 +@1582 := @1573 @2 +@1589 := {α : @446} -> {e : @637} -> {t : @19} -> (h : @692) -> (o : @1547) -> @13 @1550 @1552 +@1590 := @1582 @1463 +@1591 := (a._@._internal._hyg.#0 : @1463) -> @18 +@1592 := (x : @1463) -> @691 +@1593 := @62 @1463 +@1601 := {e : @1591} -> {t : @19} -> (h : @1592) -> (o : @1593) -> @13 (@1469 @68 @4) @1552 +@1602 := @1590 @1467 +@1604 := (x : @1463) -> @1524 @30 +@1606 := @13 (@1470 @4) +@1610 := {t : @19} -> (h : @1604) -> (o : @1593) -> @1606 @1552 +@1611 := @1602 @1473 +@1614 := (h : @1540) -> (o : @1593) -> @1606 @1475 +@1616 := @1611 @1546 @1385 +@1618 := @13 @1471 @1475 +@1619 := LexLeanTarget.TargetSyntax.Value.bool +@1620 := @1619 @1387 +@1621 := LexLeanTarget.TargetSyntax.Ty.bool +@1622 := Bool +@1623 := @1619 @4 +@1629 := {p : @24} -> {c : @25} -> {A : @26} -> (b : @1622) -> @224 @1623 @1621 +@1631 := LexLeanPreservation.Rust.wt_bool @0 +@1636 := {c : @25} -> {A : @26} -> (b : @1622) -> @234 @1623 @1621 +@1637 := @1631 @1 +@1641 := {A : @26} -> (b : @1622) -> @241 @1623 @1621 +@1642 := @1637 @2 +@1645 := (b : @1622) -> @13 @1623 @1621 +@1646 := @1642 @1387 +@1648 := @13 @1620 @1621 +@1649 := @907 @1389 +@1651 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_3 @1389 +@1653 := @251 @1649 @22 +@1655 := @251 @1620 @1653 +@1657 := @251 @1471 @1655 +@1659 := @251 @1429 @1657 +@1661 := @251 @1392 @1659 +@1662 := @254 @910 +@1663 := @1662 @23 +@1664 := @254 @1621 +@1665 := @1664 @1663 +@1666 := @254 @1475 +@1667 := @1666 @1665 +@1668 := @254 @1430 +@1669 := @1668 @1667 +@1670 := @254 @1393 +@1671 := @1670 @1669 +@1672 := @312 @1649 +@1674 := @907 (@1388 @68) +@1687 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @1674 @28) -> (hs : @142) -> @54 (@251 (@907 (@1388 @79)) @68) @269 +@1688 := @1672 @910 +@1690 := @907 (@1388 @28) +@1692 := @13 @1690 @910 +@1697 := @54 (@251 (@907 (@1388 @88)) @68) +@1698 := @1662 @28 +@1703 := {vs : @59} -> {ts : @60} -> (h : @1692) -> (hs : @142) -> @1697 @1698 +@1704 := @1688 @22 +@1706 := @907 (@1388 @30) +@1708 := @13 @1706 @910 +@1710 := @251 @1674 @22 +@1715 := {ts : @60} -> (h : @1708) -> (hs : @175) -> @54 @1710 @1698 +@1716 := @1704 @23 +@1718 := @13 @1649 @910 +@1720 := @251 @1690 @22 +@1721 := @54 @1720 +@1724 := (h : @1718) -> (hs : @56) -> @1721 @1663 +@1725 := @1716 @1651 +@1727 := @251 @1706 @22 +@1729 := @54 @1727 @1663 +@1730 := (hs : @56) -> @1729 +@1731 := @1725 @53 +@1733 := @54 @1653 @1663 +@1734 := @312 @1620 +@1736 := @1619 (@1386 @68) +@1749 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @1736 @28) -> (hs : @142) -> @54 (@251 (@1619 (@1386 @79)) @68) @269 +@1750 := @1734 @1621 +@1752 := @1619 (@1386 @28) +@1754 := @13 @1752 @1621 +@1759 := @54 (@251 (@1619 (@1386 @88)) @68) +@1760 := @1664 @28 +@1765 := {vs : @59} -> {ts : @60} -> (h : @1754) -> (hs : @142) -> @1759 @1760 +@1766 := @1750 @1653 +@1768 := @1619 (@1386 @30) +@1770 := @13 @1768 @1621 +@1771 := @1721 @30 +@1773 := @251 @1736 @1710 +@1778 := {ts : @60} -> (h : @1770) -> (hs : @1771) -> @54 @1773 @1760 +@1779 := @1766 @1663 +@1781 := @251 @1752 @1720 +@1782 := @54 @1781 +@1785 := (h : @1648) -> (hs : @1729) -> @1782 @1665 +@1786 := @1779 @1646 +@1788 := @251 @1768 @1727 +@1790 := @54 @1788 @1665 +@1791 := (hs : @1733) -> @1790 +@1792 := @1786 @1731 +@1794 := @54 @1655 @1665 +@1795 := @312 @1471 +@1797 := @1470 (@1384 @68) +@1810 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @1797 @28) -> (hs : @142) -> @54 (@251 (@1470 (@1384 @79)) @68) @269 +@1811 := @1795 @1475 +@1813 := @1470 (@1384 @28) +@1815 := @13 @1813 @1475 +@1820 := @54 (@251 (@1470 (@1384 @88)) @68) +@1821 := @1666 @28 +@1826 := {vs : @59} -> {ts : @60} -> (h : @1815) -> (hs : @142) -> @1820 @1821 +@1827 := @1811 @1655 +@1829 := @1470 (@1384 @30) +@1831 := @13 @1829 @1475 +@1832 := @1782 @30 +@1834 := @251 @1797 @1773 +@1839 := {ts : @60} -> (h : @1831) -> (hs : @1832) -> @54 @1834 @1821 +@1840 := @1827 @1665 +@1842 := @251 @1813 @1781 +@1843 := @54 @1842 +@1846 := (h : @1618) -> (hs : @1790) -> @1843 @1667 +@1847 := @1840 @1616 +@1849 := @251 @1829 @1788 +@1851 := @54 @1849 @1667 +@1852 := (hs : @1794) -> @1851 +@1853 := @1847 @1792 +@1855 := @54 @1657 @1667 +@1856 := @312 @1429 +@1858 := @1428 (@1382 @68) +@1871 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @1858 @28) -> (hs : @142) -> @54 (@251 (@1428 (@1382 @79)) @68) @269 +@1872 := @1856 @1430 +@1874 := @1428 (@1382 @28) +@1876 := @13 @1874 @1430 +@1881 := @54 (@251 (@1428 (@1382 @88)) @68) +@1882 := @1668 @28 +@1887 := {vs : @59} -> {ts : @60} -> (h : @1876) -> (hs : @142) -> @1881 @1882 +@1888 := @1872 @1657 +@1890 := @1428 (@1382 @30) +@1892 := @13 @1890 @1430 +@1893 := @1843 @30 +@1895 := @251 @1858 @1834 +@1900 := {ts : @60} -> (h : @1892) -> (hs : @1893) -> @54 @1895 @1882 +@1901 := @1888 @1667 +@1903 := @251 @1874 @1842 +@1904 := @54 @1903 +@1907 := (h : @1461) -> (hs : @1851) -> @1904 @1669 +@1908 := @1901 @1459 +@1910 := @251 @1890 @1849 +@1912 := @54 @1910 @1669 +@1913 := (hs : @1855) -> @1912 +@1914 := @1908 @1853 +@1916 := @54 @1659 @1669 +@1917 := @312 @1392 +@1919 := @1391 (@1380 @68) +@1932 := {t : @19} -> + {vs : @59} -> + {ts : @60} -> (h : @13 @1919 @28) -> (hs : @142) -> @54 (@251 (@1391 (@1380 @79)) @68) @269 +@1933 := @1917 @1393 +@1935 := @1391 (@1380 @28) +@1937 := @13 @1935 @1393 +@1942 := @54 (@251 (@1391 (@1380 @88)) @68) +@1943 := @1670 @28 +@1948 := {vs : @59} -> {ts : @60} -> (h : @1937) -> (hs : @142) -> @1942 @1943 +@1949 := @1933 @1659 +@1951 := @1391 (@1380 @30) +@1953 := @13 @1951 @1393 +@1954 := @1904 @30 +@1956 := @251 @1919 @1895 +@1961 := {ts : @60} -> (h : @1953) -> (hs : @1954) -> @54 @1956 @1943 +@1962 := @1949 @1669 +@1964 := @251 @1935 @1903 +@1965 := @54 @1964 +@1968 := (h : @1426) -> (hs : @1912) -> @1965 @1671 +@1969 := @1962 @1424 +@1971 := @251 @1951 @1910 +@1973 := @54 @1971 @1671 +@1974 := (hs : @1916) -> @1973 +@1975 := @1969 @1914 +@1977 := @54 @1661 @1671 +@1978 := @140 @192 +@1979 := @105 @192 +@1988 := {k : @57} -> + {fs : @59} -> {tys : @60} -> (h : @64 (@1979 @28) @74) -> (hf : @142) -> @143 @1376 +@1989 := @1978 @9 +@1990 := @1979 @9 +@1991 := @64 @1990 +@1992 := @1991 @74 +@1997 := {fs : @59} -> {tys : @60} -> (h : @1992) -> (hf : @142) -> @168 @1376 +@1998 := @1989 @1661 +@2005 := {tys : @60} -> (h : @1992) -> (hf : @1965 @30) -> @13 (@166 @1956) @1376 +@2006 := @1998 @1671 +@2013 := (h : @1991 (@73 @1671)) -> (hf : @1973) -> @13 (@166 @1964) @1376 +@2015 := @2006 (@188 @1990) +@2019 := (hf : @1977) -> @13 (@166 @1971) @1376 +@2020 := @2015 @1975 +@2023 := @13 (@166 @1661) @1376 +@2024 := fun (__s : @1373) => @2020 +@2025 := @246 @30 +@2026 := @558 @18 +@2030 := Prod.mk.{0, 0} @57 @18 @9 +@2031 := @2030 @352 +@2032 := @20 @2026 +@2033 := @21 @2026 +@2035 := @2033 @2031 @2032 +@2036 := Bool.true +@2037 := LexLeanTarget.TargetSyntax.Function +@2038 := LexLeanTarget.TargetSyntax.Program.functions +@2039 := @2038 @0 +@2040 := @20 @57 +@2041 := LexLeanTarget.TargetSyntax.Ty.unit +@2042 := LexLeanTarget.TargetSyntax.Value.unit +@2045 := LexLeanTarget.TargetSyntax.Expr.value @2041 @2042 +@2050 := LexLeanTarget.TargetSyntax.Function.mk @2040 @23 @2041 @2045 +@2055 := List.getD.{0} @2037 @2039 @9 @2050 +@2059 := fun (__e_n : @57) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.root @4 @9 +@2060 := @312 @352 +@2062 := @13 @341 @28 +@2063 := @219 @66 +@2064 := @251 @2063 +@2072 := {t : @19} -> {vs : @59} -> {ts : @60} -> (h : @2062) -> (hs : @142) -> @54 (@2064 @68) @269 +@2073 := @2060 @221 +@2079 := {vs : @59} -> {ts : @60} -> (h : @325 @221) -> (hs : @142) -> @330 @345 +@2080 := @2073 @22 +@2081 := @342 @22 +@2082 := @54 @2081 +@2086 := {ts : @60} -> (h : @340) -> (hs : @175) -> @2082 @345 +@2087 := @2080 @23 +@2090 := (h : @354) -> (hs : @56) -> @357 @256 +@2092 := @2087 @2025 @53 +@2093 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.denote +@2094 := @2093 @30 +@2095 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.__fits_0 +@2096 := @2095 @30 +@2099 := @219 (Reasoning.Main.planLeft @30) +@2101 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.root @30 +@2102 := Ne.{1} +@2103 := LexLeanPreservation.Obs +@2104 := @2102 @2103 +@2105 := LexLeanPreservation.Rel +@2108 := @2104 (@2105 @30 @4) +@2109 := LexLeanPreservation.Obs.stuck +@2112 := (f : @1622) -> (v : @18) -> @2108 @2109 +@2114 := LexLeanPreservation.Rust.rel_ne_stuck @2096 +@2120 := (v : @18) -> @2104 (@2105 (@2095 @28) @4) @2109 +@2121 := @2114 @2099 +@2125 := @2104 (@2105 @2096 @2099) @2109 +@2126 := @58 @2026 +@2127 := LexLeanPreservation.Rust.FunSem +@2133 := (n : @57) -> @2127 @448 @83 @76 @4 @66 +@2134 := @62 @2037 +@2135 := @61 @2134 +@2142 := LexLeanRuntime.index (@58 @2037) @2037 (LexLeanRuntime.instIndexableList @2037) +@2146 := @2135 (@2142 (@2038 @448) @66) +@2147 := @72 @2037 +@2148 := @2147 @79 +@2149 := @2146 @2148 +@2153 := @27 @456 @448 @83 @79 +@2154 := LexLeanTarget.TargetSyntax.Function.types +@2155 := @2154 @66 +@2156 := @2153 @2155 +@2157 := @62 @2126 +@2158 := @61 @2157 +@2159 := LexLeanTarget.TargetSemantics.bindAll +@2160 := LexLeanTarget.TargetSyntax.Function.parameters +@2165 := @2158 (@2159 (@2160 @76) @66 @2032) +@2166 := @72 @2126 +@2167 := @2166 @79 +@2168 := @2165 @2167 +@2169 := @62 @1622 +@2170 := @61 @2169 +@2171 := LexLeanPreservation.Rust.fnFallible +@2174 := @2170 (@2171 @466 @448) +@2175 := @72 @1622 +@2176 := @2175 @79 +@2177 := @2174 @2176 +@2178 := LexLeanPreservation.RunConv +@2179 := #13 +@2183 := @2178 @2179 @456 @83 @79 +@2185 := @2104 @66 @2109 +@2186 := Exists.{1} +@2187 := LexLeanPreservation.Rust.ROut +@2188 := @2186 @2187 +@2189 := And +@2190 := LexLeanPreservation.Rust.RealizesFn +@2194 := @2189 (@2190 @448 @83 @4) +@2195 := LexLeanPreservation.Rust.RCI +@2197 := @2195 #15 +@2198 := LexLeanPreservation.Rust.fnIdent +@2199 := @2198 @2179 +@2206 := (hne : @2185) -> @2188 (fun (ro : @2187) => @2194 (@2197 @2199 @466 @4)) +@2221 := {p : @24} -> + {c : @25} -> + {A : @26} -> + {f : @57} -> + {fn : @2037} -> + {args : @59} -> + {env : @2126} -> + {F : @1622} -> + {o : @2103} -> + (hB : @2133) -> + (hfn : @2149) -> (hwt : @2156) -> (hbind : @2168) -> (hF : @2177) -> (hA : @2183) -> @2206 +@2223 := LexLeanPreservation.Rust.compose @0 +@2224 := @2127 @0 +@2229 := (n : @57) -> @2224 @83 @76 @4 @66 +@2230 := @2142 @2039 +@2233 := @2135 (@2230 @66) @2148 +@2237 := @40 @448 @83 @79 @2155 +@2238 := @2178 @0 +@2241 := @2238 @456 @83 @79 +@2255 := {c : @25} -> + {A : @26} -> + {f : @57} -> + {fn : @2037} -> + {args : @59} -> + {env : @2126} -> + {F : @1622} -> + {o : @2103} -> + (hB : @2229) -> + (hfn : @2233) -> (hwt : @2237) -> (hbind : @2168) -> (hF : @2177) -> (hA : @2241) -> @2206 +@2256 := @2223 @1 +@2257 := @2224 @1 +@2261 := (n : @57) -> @2257 @76 @4 @66 +@2264 := @48 @83 @79 @2155 +@2265 := @2171 @1 +@2268 := @2170 (@2265 @448) @2176 +@2269 := @2195 @1 +@2279 := (hbind : @2168) -> + (hF : @2268) -> + (hA : @2241) -> (hne : @2185) -> @2188 (fun (ro : @2187) => @2194 (@2269 @2199 @466 @4)) +@2289 := {A : @26} -> + {f : @57} -> + {fn : @2037} -> + {args : @59} -> + {env : @2126} -> + {F : @1622} -> {o : @2103} -> (hB : @2261) -> (hfn : @2233) -> (hwt : @2264) -> @2279 +@2290 := @2256 @2 +@2292 := @2257 @2 @4 +@2294 := (n : @57) -> @2292 @66 +@2295 := @54 @79 +@2296 := @2295 @2155 +@2305 := {f : @57} -> + {fn : @2037} -> + {args : @59} -> + {env : @2126} -> + {F : @1622} -> {o : @2103} -> (hB : @2294) -> (hfn : @2233) -> (hwt : @2296) -> @2279 +@2306 := @2290 @9 +@2308 := (n : @57) -> @2292 @9 +@2309 := @2230 @9 +@2310 := @2135 @2309 +@2311 := @2310 @2148 +@2312 := @2265 @9 +@2313 := @2170 @2312 +@2314 := @2313 @2176 +@2315 := @2238 @9 +@2317 := @2315 @83 @79 +@2319 := @2269 (@2198 @9) +@2327 := (hF : @2314) -> + (hA : @2317) -> (hne : @2185) -> @2188 (fun (ro : @2187) => @2194 (@2319 @466 @4)) +@2336 := {fn : @2037} -> + {args : @59} -> + {env : @2126} -> + {F : @1622} -> + {o : @2103} -> (hB : @2308) -> (hfn : @2311) -> (hwt : @2296) -> (hbind : @2168) -> @2327 +@2337 := @2306 @2055 +@2339 := @2310 (@2147 @2055) +@2340 := @2154 @2055 +@2341 := @2295 @2340 +@2343 := @2159 (@2160 @2055) +@2355 := {args : @59} -> + {env : @2126} -> + {F : @1622} -> + {o : @2103} -> + (hB : @2308) -> (hfn : @2339) -> (hwt : @2341) -> (hbind : @2158 (@2343 @66 @2032) @2167) -> @2327 +@2356 := @2337 @371 +@2357 := @2064 @22 +@2359 := @54 @2357 @2340 +@2362 := @251 (@219 @76) @22 +@2366 := @2158 (@2343 @2362 @2032) @2167 +@2369 := @251 (@219 @448) @22 +@2390 := {env : @2126} -> + {F : @1622} -> + {o : @2103} -> + (hB : @2308) -> + (hfn : @2339) -> + (hwt : @2359) -> + (hbind : @2366) -> + (hF : @2314) -> + (hA : @2315 @2369 @79) -> + (hne : @2185) -> @2188 (fun (ro : @2187) => @2194 (@2319 (@251 (@219 #12) @22) @4)) +@2391 := @2356 @2035 +@2392 := @328 @22 +@2394 := @54 @2392 @2340 +@2402 := @2158 (@2343 @2357 @2032) (@2166 (@2033 (@2030 @2063) @2032)) +@2405 := @251 (@219 @83) @22 +@2424 := {F : @1622} -> + {o : @2103} -> + (hB : @2308) -> + (hfn : @2339) -> + (hwt : @2394) -> + (hbind : @2402) -> + (hF : @2314) -> + (hA : @2315 @2405 @79) -> + (hne : @2185) -> @2188 (fun (ro : @2187) => @2194 (@2319 (@251 (@219 @466) @22) @4)) +@2425 := @2391 @2036 +@2426 := @2082 @2340 +@2434 := @2158 (@2343 @2392 @2032) (@2166 (@2033 (@2030 @327) @2032)) +@2436 := @2313 (@2175 @2036) +@2438 := @2315 @2362 @79 +@2439 := @2190 @2036 +@2458 := {o : @2103} -> + (hB : @2308) -> + (hfn : @2339) -> + (hwt : @2426) -> + (hbind : @2434) -> + (hF : @2436) -> + (hA : @2438) -> + (hne : @2185) -> + @2188 (fun (ro : @2187) => @2189 (@2439 @83 @4) (@2319 (@251 (@219 @456) @22) @4)) +@2459 := @2425 @2094 +@2460 := @357 @2340 +@2468 := @2158 (@2343 @2081 @2032) (@2166 (@2033 (@2030 @341) @2032)) +@2469 := @2315 @2357 +@2470 := @2093 @66 +@2471 := @2469 @2470 +@2472 := @2093 @76 +@2490 := (hB : @2308) -> + (hfn : @2339) -> + (hwt : @2460) -> + (hbind : @2468) -> + (hF : @2436) -> + (hA : @2471) -> + (hne : @2104 @2472 @2109) -> + @2188 (fun (ro : @2187) => @2189 (@2439 (@2093 @448) @4) (@2319 @2369 @4)) +@2491 := @2459 @2059 +@2492 := @365 @2340 +@2500 := @2158 (@2343 @356 @2032) (@2166 (@2033 (@2030 @324) @2032)) +@2501 := @2315 @2392 +@2502 := @2093 @79 +@2520 := (hfn : @2339) -> + (hwt : @2492) -> + (hbind : @2500) -> + (hF : @2436) -> + (hA : @2501 @2502) -> + (hne : @2104 @2470 @2109) -> + @2188 (fun (ro : @2187) => @2189 (@2439 (@2093 @83) @4) (@2319 @2405 @4)) +@2523 := @2491 (@187 @2134 @2309) +@2524 := @372 @2340 +@2532 := @2158 (@2343 @364 @2032) (@2166 (@2033 (@2030 @338) @2032)) +@2533 := @2315 @2081 +@2534 := @2093 @88 +@2550 := (hwt : @2524) -> + (hbind : @2532) -> + (hF : @2436) -> + (hA : @2533 @2534) -> + (hne : @2104 @2502 @2109) -> @2188 (fun (ro : @2187) => @2189 (@2439 @2472 @4) (@2319 @2362 @4)) +@2551 := @2523 @2092 +@2553 := @2343 @371 @2032 +@2556 := @2158 @2553 (@2166 @2035) +@2557 := @2315 @356 +@2558 := @2093 @68 +@2573 := (hbind : @2556) -> + (hF : @2436) -> + (hA : @2557 @2558) -> + (hne : @2104 @2534 @2109) -> @2188 (fun (ro : @2187) => @2189 (@2439 @2470 @4) (@2319 @2357 @4)) +@2576 := @2551 (@187 @2157 @2553) +@2577 := @2315 @364 +@2578 := @2093 @28 +@2592 := (hF : @2436) -> + (hA : @2577 @2578) -> + (hne : @2104 @2558 @2109) -> @2188 (fun (ro : @2187) => @2189 (@2439 @2502 @4) (@2319 @2392 @4)) +@2595 := @2576 (@187 @2169 @2312) +@2609 := (hA : @2315 @371 @2094) -> + (hne : @2104 @2578 @2109) -> @2188 (fun (ro : @2187) => @2189 (@2439 @2534 @4) (@2319 @2081 @4)) +@2610 := @2595 @2101 +@2621 := (hne : @2104 @2094 @2109) -> + @2188 (fun (ro : @2187) => @2189 (@2439 @2558 @4) (@2319 @356 @4)) +@2622 := @2610 @2121 +@2628 := @2189 (@2439 @2578 @4) (@2319 @364 @4) +@2630 := @2188 (fun (ro : @2187) => @2628) +@2632 := @2188 (fun (__e_ro : @2187) => @2628) +@2634 := LexLeanPreservation.Rust.RepresentableL @253 +@2635 := (__e_hrep : @2634) -> @2632 +@2636 := fun (__e_hrep : @2634) => @2622 +@2637 := (target : @57) -> @2635 +@2638 := fun (target : @57) => @2636 +\end{coremodule} +\end{lexlean} diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R4/Compose/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R4/Compose/RustStd.lean deleted file mode 100644 index c02217025..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R4/Compose/RustStd.lean +++ /dev/null @@ -1,22 +0,0 @@ -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4 -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd - -theorem __wt_1 : ∀ (__s : (Reasoning.Screening.Dose.Ledger)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.__enc_1 __s) (.adt 1) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).iterations) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).attempts) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).firings) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).expansions) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).verifications) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).frontier) _root_.LexLeanPreservation.Rust.wtl_nil)))))) - -theorem __wt_0 : ∀ (__s : (Reasoning.Screening.Dose.Trial)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.__enc_0 __s) (.adt 0) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encOption _root_.LexLeanPreservation.Rust.wt_nat) (__s).found) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_bool (__s).truncated) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_1 (__s).ledger) _root_.LexLeanPreservation.Rust.wtl_nil))) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (w : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat w)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.denote w) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat w)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat w) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.root w) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R4/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R4/Compose/RustStd.lex.tex new file mode 100644 index 000000000..4cbc6ffa7 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R4/Compose/RustStd.lex.tex @@ -0,0 +1,877 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4, + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.__wt_1 : @16 := @717 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.__wt_0 : @724 := @1108 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.root : @1754 := @1755 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.program +@1 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.krate +@2 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.flags +@3 := Reasoning.Screening.Dose.Ledger +@4 := #0 +@5 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.__enc_1 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 1 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@16 := (__s : @3) -> @13 @6 @10 +@17 := Reasoning.Screening.Dose.Ledger.iterations +@18 := @17 @4 +@19 := Reasoning.Screening.Dose.Ledger.attempts +@20 := @19 @4 +@21 := Reasoning.Screening.Dose.Ledger.firings +@22 := @21 @4 +@23 := Reasoning.Screening.Dose.Ledger.expansions +@24 := @23 @4 +@25 := Reasoning.Screening.Dose.Ledger.verifications +@26 := @25 @4 +@27 := Reasoning.Screening.Dose.Ledger.frontier +@28 := @27 @4 +@29 := LexLeanTarget.TargetSyntax.Value.nat +@30 := @29 @18 +@31 := LexLeanTarget.TargetSyntax.Ty.nat +@32 := LexLeanTarget.TargetSyntax.Program +@33 := LexLeanPreservation.Rust.RCrate +@34 := LexLeanPreservation.Rust.Flags +@35 := Nat +@36 := #3 +@37 := @7 @36 +@38 := #2 +@39 := @37 @38 +@40 := #1 +@41 := @39 @40 +@42 := @29 @4 +@48 := {p : @32} -> {c : @33} -> {A : @34} -> (n : @35) -> @41 @42 @31 +@50 := LexLeanPreservation.Rust.wt_nat @0 +@52 := @11 @38 @40 +@57 := {c : @33} -> {A : @34} -> (n : @35) -> @52 @42 @31 +@58 := @50 @1 +@59 := @12 @40 +@63 := {A : @34} -> (n : @35) -> @59 @42 @31 +@64 := @58 @2 +@65 := @13 @42 +@66 := @65 @31 +@67 := (n : @35) -> @66 +@68 := @64 @18 +@70 := @13 @30 @31 +@71 := @29 @20 +@72 := @64 @20 +@74 := @13 @71 @31 +@75 := @29 @22 +@76 := @64 @22 +@78 := @13 @75 @31 +@79 := @29 @24 +@80 := @64 @24 +@82 := @13 @79 @31 +@83 := @29 @26 +@84 := @64 @26 +@86 := @13 @83 @31 +@87 := @29 @28 +@88 := @64 @28 +@90 := @13 @87 @31 +@91 := LexLeanTarget.TargetSyntax.Value +@92 := LexLeanTarget.TargetSyntax.Ty +@93 := List.nil.{0} +@94 := List.cons.{0} +@95 := @93 @91 +@96 := @94 @91 +@98 := @96 @87 @95 +@100 := @96 @83 @98 +@102 := @96 @79 @100 +@104 := @96 @75 @102 +@106 := @96 @71 @104 +@108 := @96 @30 @106 +@109 := @93 @92 +@110 := @94 @92 +@111 := @110 @31 +@112 := @111 @109 +@113 := @111 @112 +@114 := @111 @113 +@115 := @111 @114 +@116 := @111 @115 +@117 := @111 @116 +@118 := LexLeanPreservation.Rust.WTL +@126 := {p : @32} -> {c : @33} -> {A : @34} -> @118 @38 @40 @4 @95 @109 +@128 := LexLeanPreservation.Rust.wtl_nil @0 +@129 := @118 @0 +@135 := {c : @33} -> {A : @34} -> @129 @40 @4 @95 @109 +@136 := @128 @1 +@137 := @129 @1 +@141 := {A : @34} -> @137 @4 @95 @109 +@142 := @136 @2 +@143 := @137 @2 +@144 := @143 @95 +@145 := @144 @109 +@146 := List.{0} +@147 := @146 @91 +@148 := @146 @92 +@149 := #6 +@150 := @7 @149 +@151 := #5 +@152 := @150 @151 +@153 := #4 +@154 := @152 @153 +@156 := @154 @36 @38 +@157 := #7 +@162 := @118 @157 @149 @151 @38 @40 +@163 := #8 +@166 := @118 @163 @157 @149 +@168 := @96 @151 @36 +@169 := @166 @168 +@171 := @110 @153 @38 +@181 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {v : @91} -> {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @156) -> (hs : @162) -> @169 @171 +@183 := LexLeanPreservation.Rust.wtl_cons @0 +@185 := @11 @151 @153 +@187 := @185 @36 @38 +@191 := @129 @149 @151 @38 @40 +@203 := {c : @33} -> + {A : @34} -> + {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @187) -> (hs : @191) -> @129 @157 @149 @168 @171 +@204 := @183 @1 +@205 := @12 @153 +@207 := @205 @36 @38 +@210 := @137 @151 @38 @40 +@220 := {A : @34} -> + {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @207) -> (hs : @210) -> @137 @149 @168 @171 +@221 := @204 @2 +@223 := @13 @36 @38 +@225 := @143 @38 @40 +@233 := {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @223) -> (hs : @225) -> @143 @168 @171 +@234 := @221 @87 +@236 := @29 (@27 @36) +@249 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @236 @38) -> (hs : @225) -> @143 (@96 (@29 (@27 @151)) @36) @171 +@250 := @234 @31 +@252 := @29 (@27 @38) +@254 := @13 @252 @31 +@259 := @143 (@96 (@29 (@27 @153)) @36) +@260 := @111 @38 +@265 := {vs : @147} -> {ts : @148} -> (h : @254) -> (hs : @225) -> @259 @260 +@266 := @250 @95 +@268 := @29 (@27 @40) +@270 := @13 @268 @31 +@271 := @144 @40 +@273 := @96 @236 @95 +@278 := {ts : @148} -> (h : @270) -> (hs : @271) -> @143 @273 @260 +@279 := @266 @109 +@281 := @96 @252 @95 +@282 := @143 @281 +@285 := (h : @90) -> (hs : @145) -> @282 @112 +@286 := @279 @88 +@288 := @96 @268 @95 +@290 := @143 @288 @112 +@291 := (hs : @145) -> @290 +@292 := @286 @142 +@294 := @143 @98 @112 +@295 := @221 @83 +@297 := @29 (@25 @36) +@310 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @297 @38) -> (hs : @225) -> @143 (@96 (@29 (@25 @151)) @36) @171 +@311 := @295 @31 +@313 := @29 (@25 @38) +@325 := {vs : @147} -> + {ts : @148} -> (h : @13 @313 @31) -> (hs : @225) -> @143 (@96 (@29 (@25 @153)) @36) @260 +@326 := @311 @98 +@328 := @29 (@25 @40) +@330 := @13 @328 @31 +@331 := @282 @40 +@333 := @96 @297 @273 +@338 := {ts : @148} -> (h : @330) -> (hs : @331) -> @143 @333 @260 +@339 := @326 @112 +@341 := @96 @313 @281 +@342 := @143 @341 +@345 := (h : @86) -> (hs : @290) -> @342 @113 +@346 := @339 @84 +@348 := @96 @328 @288 +@350 := @143 @348 @113 +@351 := (hs : @294) -> @350 +@352 := @346 @292 +@354 := @143 @100 @113 +@355 := @221 @79 +@357 := @29 (@23 @36) +@370 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @357 @38) -> (hs : @225) -> @143 (@96 (@29 (@23 @151)) @36) @171 +@371 := @355 @31 +@373 := @29 (@23 @38) +@385 := {vs : @147} -> + {ts : @148} -> (h : @13 @373 @31) -> (hs : @225) -> @143 (@96 (@29 (@23 @153)) @36) @260 +@386 := @371 @100 +@388 := @29 (@23 @40) +@390 := @13 @388 @31 +@391 := @342 @40 +@393 := @96 @357 @333 +@398 := {ts : @148} -> (h : @390) -> (hs : @391) -> @143 @393 @260 +@399 := @386 @113 +@401 := @96 @373 @341 +@402 := @143 @401 +@405 := (h : @82) -> (hs : @350) -> @402 @114 +@406 := @399 @80 +@408 := @96 @388 @348 +@410 := @143 @408 @114 +@411 := (hs : @354) -> @410 +@412 := @406 @352 +@414 := @143 @102 @114 +@415 := @221 @75 +@417 := @29 (@21 @36) +@430 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @417 @38) -> (hs : @225) -> @143 (@96 (@29 (@21 @151)) @36) @171 +@431 := @415 @31 +@433 := @29 (@21 @38) +@445 := {vs : @147} -> + {ts : @148} -> (h : @13 @433 @31) -> (hs : @225) -> @143 (@96 (@29 (@21 @153)) @36) @260 +@446 := @431 @102 +@448 := @29 (@21 @40) +@450 := @13 @448 @31 +@451 := @402 @40 +@453 := @96 @417 @393 +@458 := {ts : @148} -> (h : @450) -> (hs : @451) -> @143 @453 @260 +@459 := @446 @114 +@461 := @96 @433 @401 +@462 := @143 @461 +@465 := (h : @78) -> (hs : @410) -> @462 @115 +@466 := @459 @76 +@468 := @96 @448 @408 +@470 := @143 @468 @115 +@471 := (hs : @414) -> @470 +@472 := @466 @412 +@474 := @143 @104 @115 +@475 := @221 @71 +@477 := @29 (@19 @36) +@490 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @477 @38) -> (hs : @225) -> @143 (@96 (@29 (@19 @151)) @36) @171 +@491 := @475 @31 +@493 := @29 (@19 @38) +@505 := {vs : @147} -> + {ts : @148} -> (h : @13 @493 @31) -> (hs : @225) -> @143 (@96 (@29 (@19 @153)) @36) @260 +@506 := @491 @104 +@508 := @29 (@19 @40) +@510 := @13 @508 @31 +@511 := @462 @40 +@513 := @96 @477 @453 +@518 := {ts : @148} -> (h : @510) -> (hs : @511) -> @143 @513 @260 +@519 := @506 @115 +@521 := @96 @493 @461 +@522 := @143 @521 +@525 := (h : @74) -> (hs : @470) -> @522 @116 +@526 := @519 @72 +@528 := @96 @508 @468 +@530 := @143 @528 @116 +@531 := (hs : @474) -> @530 +@532 := @526 @472 +@534 := @143 @106 @116 +@535 := @221 @30 +@537 := @29 (@17 @36) +@550 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @537 @38) -> (hs : @225) -> @143 (@96 (@29 (@17 @151)) @36) @171 +@551 := @535 @31 +@553 := @29 (@17 @38) +@565 := {vs : @147} -> + {ts : @148} -> (h : @13 @553 @31) -> (hs : @225) -> @143 (@96 (@29 (@17 @153)) @36) @260 +@566 := @551 @106 +@568 := @29 (@17 @40) +@570 := @13 @568 @31 +@571 := @522 @40 +@573 := @96 @537 @513 +@578 := {ts : @148} -> (h : @570) -> (hs : @571) -> @143 @573 @260 +@579 := @566 @116 +@581 := @96 @553 @521 +@582 := @143 @581 +@585 := (h : @70) -> (hs : @530) -> @582 @117 +@586 := @579 @68 +@588 := @96 @568 @528 +@590 := @143 @588 @117 +@591 := (hs : @534) -> @590 +@592 := @586 @532 +@594 := @143 @108 @117 +@595 := 0 +@596 := Eq.{1} +@597 := Option.{0} +@598 := @597 @148 +@599 := @596 @598 +@600 := LexLeanPreservation.Rust.adtFields +@604 := @599 (@600 @149 @36 @38) +@605 := Option.some.{0} +@606 := @605 @148 +@607 := @606 @4 +@608 := @604 @607 +@611 := @7 @163 @157 @149 +@612 := LexLeanTarget.TargetSyntax.Value.adt +@614 := @612 @153 @36 +@615 := @611 @614 +@616 := @8 @151 +@626 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {i : @35} -> {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @608) -> (hf : @162) -> @615 @616 +@628 := LexLeanPreservation.Rust.wt_adt @0 +@629 := @600 @0 +@633 := @599 (@629 @36 @38) @607 +@645 := {c : @33} -> + {A : @34} -> + {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @633) -> (hf : @191) -> @11 @157 @149 @614 @616 +@646 := @628 @1 +@656 := {A : @34} -> + {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @633) -> (hf : @210) -> @12 @149 @614 @616 +@657 := @646 @2 +@658 := @13 @614 +@665 := {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @633) -> (hf : @225) -> @658 @616 +@666 := @657 @9 +@667 := @629 @9 +@676 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @599 (@667 @38) @607) -> (hf : @225) -> @658 @10 +@677 := @666 @595 +@678 := @667 @595 +@679 := @599 @678 +@680 := @679 @607 +@681 := @612 @595 +@683 := @13 (@681 @36) +@688 := {fs : @147} -> {tys : @148} -> (h : @680) -> (hf : @225) -> @683 @10 +@689 := @677 @108 +@696 := {tys : @148} -> (h : @680) -> (hf : @582 @40) -> @13 (@681 @573) @10 +@697 := @689 @117 +@704 := (h : @679 (@606 @117)) -> (hf : @590) -> @13 (@681 @581) @10 +@705 := Eq.refl.{1} +@706 := @705 @598 +@708 := @697 (@706 @678) +@712 := (hf : @594) -> @13 (@681 @588) @10 +@713 := @708 @592 +@716 := @13 (@681 @108) @10 +@717 := fun (__s : @3) => @713 +@718 := Reasoning.Screening.Dose.Trial +@720 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.__enc_0 @4 +@721 := @8 @595 +@724 := (__s : @718) -> @13 @720 @721 +@725 := Reasoning.Screening.Dose.Trial.found +@726 := @725 @4 +@727 := Reasoning.Screening.Dose.Trial.truncated +@728 := @727 @4 +@729 := Reasoning.Screening.Dose.Trial.ledger +@730 := @729 @4 +@731 := LexLeanPreservation.encOption +@732 := @731 @35 +@733 := @732 @29 +@734 := @733 @726 +@735 := LexLeanTarget.TargetSyntax.Ty.option +@736 := @735 @31 +@738 := fun (__x : @35) => @64 @4 +@739 := Sort 1 +@740 := (a._@._internal._hyg.#0 : @4) -> @91 +@741 := @38 @4 +@744 := (x : @38) -> @154 @741 @40 +@745 := @597 @36 +@748 := @7 @157 @149 @151 +@751 := @731 @153 @36 @4 +@752 := @748 @751 +@753 := @735 @38 +@762 := {p : @32} -> + {c : @33} -> + {A : @34} -> {α : @739} -> {e : @740} -> {t : @92} -> (h : @744) -> (o : @745) -> @752 @753 +@764 := LexLeanPreservation.Rust.wt_encOption @0 +@778 := {c : @33} -> + {A : @34} -> + {α : @739} -> + {e : @740} -> + {t : @92} -> (h : (x : @38) -> @185 @741 @40) -> (o : @745) -> @11 @149 @151 @751 @753 +@779 := @764 @1 +@791 := {A : @34} -> + {α : @739} -> + {e : @740} -> {t : @92} -> (h : (x : @38) -> @205 @741 @40) -> (o : @745) -> @12 @151 @751 @753 +@792 := @779 @2 +@794 := @13 @741 @40 +@802 := {α : @739} -> + {e : @740} -> {t : @92} -> (h : (x : @38) -> @794) -> (o : @745) -> @13 @751 @753 +@803 := @792 @35 +@804 := (a._@._internal._hyg.#0 : @35) -> @91 +@805 := (x : @35) -> @794 +@806 := @597 @35 +@814 := {e : @804} -> {t : @92} -> (h : @805) -> (o : @806) -> @13 (@732 @36 @4) @753 +@815 := @803 @29 +@817 := (x : @35) -> @65 @40 +@819 := @13 (@733 @4) +@823 := {t : @92} -> (h : @817) -> (o : @806) -> @819 @753 +@824 := @815 @31 +@828 := (h : (x : @35) -> @66) -> (o : @806) -> @819 @736 +@830 := @824 @738 @726 +@832 := @13 @734 @736 +@833 := LexLeanTarget.TargetSyntax.Value.bool +@834 := @833 @728 +@835 := LexLeanTarget.TargetSyntax.Ty.bool +@836 := Bool +@837 := @833 @4 +@843 := {p : @32} -> {c : @33} -> {A : @34} -> (b : @836) -> @41 @837 @835 +@845 := LexLeanPreservation.Rust.wt_bool @0 +@850 := {c : @33} -> {A : @34} -> (b : @836) -> @52 @837 @835 +@851 := @845 @1 +@855 := {A : @34} -> (b : @836) -> @59 @837 @835 +@856 := @851 @2 +@859 := (b : @836) -> @13 @837 @835 +@860 := @856 @728 +@862 := @13 @834 @835 +@863 := @5 @730 +@865 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.__wt_1 @730 +@867 := @96 @863 @95 +@869 := @96 @834 @867 +@871 := @96 @734 @869 +@872 := @110 @10 +@873 := @872 @109 +@874 := @110 @835 +@875 := @874 @873 +@876 := @110 @736 +@877 := @876 @875 +@878 := @221 @863 +@880 := @5 (@729 @36) +@893 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @880 @38) -> (hs : @225) -> @143 (@96 (@5 (@729 @151)) @36) @171 +@894 := @878 @10 +@896 := @5 (@729 @38) +@898 := @13 @896 @10 +@903 := @143 (@96 (@5 (@729 @153)) @36) +@904 := @872 @38 +@909 := {vs : @147} -> {ts : @148} -> (h : @898) -> (hs : @225) -> @903 @904 +@910 := @894 @95 +@912 := @5 (@729 @40) +@914 := @13 @912 @10 +@916 := @96 @880 @95 +@921 := {ts : @148} -> (h : @914) -> (hs : @271) -> @143 @916 @904 +@922 := @910 @109 +@924 := @13 @863 @10 +@926 := @96 @896 @95 +@927 := @143 @926 +@930 := (h : @924) -> (hs : @145) -> @927 @873 +@931 := @922 @865 +@933 := @96 @912 @95 +@935 := @143 @933 @873 +@936 := (hs : @145) -> @935 +@937 := @931 @142 +@939 := @143 @867 @873 +@940 := @221 @834 +@942 := @833 (@727 @36) +@955 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @942 @38) -> (hs : @225) -> @143 (@96 (@833 (@727 @151)) @36) @171 +@956 := @940 @835 +@958 := @833 (@727 @38) +@960 := @13 @958 @835 +@965 := @143 (@96 (@833 (@727 @153)) @36) +@966 := @874 @38 +@971 := {vs : @147} -> {ts : @148} -> (h : @960) -> (hs : @225) -> @965 @966 +@972 := @956 @867 +@974 := @833 (@727 @40) +@976 := @13 @974 @835 +@977 := @927 @40 +@979 := @96 @942 @916 +@984 := {ts : @148} -> (h : @976) -> (hs : @977) -> @143 @979 @966 +@985 := @972 @873 +@987 := @96 @958 @926 +@988 := @143 @987 +@991 := (h : @862) -> (hs : @935) -> @988 @875 +@992 := @985 @860 +@994 := @96 @974 @933 +@996 := @143 @994 @875 +@997 := (hs : @939) -> @996 +@998 := @992 @937 +@1000 := @143 @869 @875 +@1001 := @221 @734 +@1003 := @733 (@725 @36) +@1016 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1003 @38) -> (hs : @225) -> @143 (@96 (@733 (@725 @151)) @36) @171 +@1017 := @1001 @736 +@1019 := @733 (@725 @38) +@1021 := @13 @1019 @736 +@1026 := @143 (@96 (@733 (@725 @153)) @36) +@1027 := @876 @38 +@1032 := {vs : @147} -> {ts : @148} -> (h : @1021) -> (hs : @225) -> @1026 @1027 +@1033 := @1017 @869 +@1035 := @733 (@725 @40) +@1037 := @13 @1035 @736 +@1038 := @988 @40 +@1040 := @96 @1003 @979 +@1045 := {ts : @148} -> (h : @1037) -> (hs : @1038) -> @143 @1040 @1027 +@1046 := @1033 @875 +@1048 := @96 @1019 @987 +@1049 := @143 @1048 +@1052 := (h : @832) -> (hs : @996) -> @1049 @877 +@1053 := @1046 @830 +@1055 := @96 @1035 @994 +@1057 := @143 @1055 @877 +@1058 := (hs : @1000) -> @1057 +@1059 := @1053 @998 +@1061 := @143 @871 @877 +@1062 := @657 @595 +@1063 := @629 @595 +@1072 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @599 (@1063 @38) @607) -> (hf : @225) -> @658 @721 +@1073 := @1062 @595 +@1074 := @1063 @595 +@1075 := @599 @1074 +@1076 := @1075 @607 +@1081 := {fs : @147} -> {tys : @148} -> (h : @1076) -> (hf : @225) -> @683 @721 +@1082 := @1073 @871 +@1089 := {tys : @148} -> (h : @1076) -> (hf : @1049 @40) -> @13 (@681 @1040) @721 +@1090 := @1082 @877 +@1097 := (h : @1075 (@606 @877)) -> (hf : @1057) -> @13 (@681 @1048) @721 +@1099 := @1090 (@706 @1074) +@1103 := (hf : @1061) -> @13 (@681 @1055) @721 +@1104 := @1099 @1059 +@1107 := @13 (@681 @871) @721 +@1108 := fun (__s : @718) => @1104 +@1109 := @29 @40 +@1110 := @64 @40 +@1112 := @13 @1109 @31 +@1114 := @96 @1109 @95 +@1117 := Prod.{0, 0} @35 @91 +@1121 := Prod.mk.{0, 0} @35 @91 @595 +@1122 := @1121 @1109 +@1123 := @93 @1117 +@1124 := @94 @1117 +@1126 := @1124 @1122 @1123 +@1127 := Bool.true +@1128 := LexLeanTarget.TargetSyntax.Function +@1129 := LexLeanTarget.TargetSyntax.Program.functions +@1130 := @1129 @0 +@1131 := @93 @35 +@1132 := LexLeanTarget.TargetSyntax.Ty.unit +@1133 := LexLeanTarget.TargetSyntax.Value.unit +@1136 := LexLeanTarget.TargetSyntax.Expr.value @1132 @1133 +@1141 := LexLeanTarget.TargetSyntax.Function.mk @1131 @109 @1132 @1136 +@1146 := List.getD.{0} @1128 @1130 @595 @1141 +@1150 := fun (__e_n : @35) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.root @4 @595 +@1151 := @221 @1109 +@1152 := @29 @153 +@1154 := @13 @1152 @38 +@1155 := @29 @149 +@1156 := @96 @1155 +@1164 := {t : @92} -> + {vs : @147} -> {ts : @148} -> (h : @1154) -> (hs : @225) -> @143 (@1156 @36) @171 +@1165 := @1151 @31 +@1166 := @29 @36 +@1168 := @13 @1166 @31 +@1169 := @29 @151 +@1170 := @96 @1169 +@1177 := {vs : @147} -> {ts : @148} -> (h : @1168) -> (hs : @225) -> @143 (@1170 @36) @260 +@1178 := @1165 @95 +@1179 := @29 @38 +@1181 := @13 @1179 @31 +@1183 := @96 @1152 @95 +@1184 := @143 @1183 +@1188 := {ts : @148} -> (h : @1181) -> (hs : @271) -> @1184 @260 +@1189 := @1178 @109 +@1191 := @96 @1166 @95 +@1192 := @143 @1191 +@1195 := (h : @1112) -> (hs : @145) -> @1192 @112 +@1196 := @1189 @1110 +@1198 := @96 @1179 @95 +@1199 := @143 @1198 +@1201 := (hs : @145) -> @1199 @112 +@1202 := @1196 @142 +@1203 := @143 @1114 +@1204 := @1203 @112 +@1205 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.denote +@1206 := @1205 @40 +@1207 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.__fits_0 +@1208 := @1207 @40 +@1211 := @29 (Reasoning.Main.doseLevel @40) +@1213 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.root @40 +@1214 := Ne.{1} +@1215 := LexLeanPreservation.Obs +@1216 := @1214 @1215 +@1217 := LexLeanPreservation.Rel +@1220 := @1216 (@1217 @40 @4) +@1221 := LexLeanPreservation.Obs.stuck +@1224 := (f : @836) -> (v : @91) -> @1220 @1221 +@1226 := LexLeanPreservation.Rust.rel_ne_stuck @1208 +@1232 := (v : @91) -> @1216 (@1217 (@1207 @38) @4) @1221 +@1233 := @1226 @1211 +@1237 := @1216 (@1217 @1208 @1211) @1221 +@1238 := @146 @1117 +@1239 := LexLeanPreservation.Rust.FunSem +@1240 := #9 +@1246 := (n : @35) -> @1239 @1240 @163 @157 @4 @149 +@1247 := @597 @1128 +@1248 := @596 @1247 +@1255 := LexLeanRuntime.index (@146 @1128) @1128 (LexLeanRuntime.instIndexableList @1128) +@1259 := @1248 (@1255 (@1129 @1240) @149) +@1260 := @605 @1128 +@1261 := @1260 @151 +@1262 := @1259 @1261 +@1263 := #10 +@1267 := @118 @1263 @1240 @163 @151 +@1268 := LexLeanTarget.TargetSyntax.Function.types +@1269 := @1268 @149 +@1270 := @1267 @1269 +@1271 := @597 @1238 +@1272 := @596 @1271 +@1273 := LexLeanTarget.TargetSemantics.bindAll +@1274 := LexLeanTarget.TargetSyntax.Function.parameters +@1279 := @1272 (@1273 (@1274 @157) @149 @1123) +@1280 := @605 @1238 +@1281 := @1280 @151 +@1282 := @1279 @1281 +@1283 := @597 @836 +@1284 := @596 @1283 +@1285 := LexLeanPreservation.Rust.fnFallible +@1286 := #11 +@1289 := @1284 (@1285 @1286 @1240) +@1290 := @605 @836 +@1291 := @1290 @151 +@1292 := @1289 @1291 +@1293 := LexLeanPreservation.RunConv +@1294 := #13 +@1298 := @1293 @1294 @1263 @163 @151 +@1300 := @1216 @149 @1221 +@1301 := Exists.{1} +@1302 := LexLeanPreservation.Rust.ROut +@1303 := @1301 @1302 +@1304 := And +@1305 := LexLeanPreservation.Rust.RealizesFn +@1309 := @1304 (@1305 @1240 @163 @4) +@1310 := LexLeanPreservation.Rust.RCI +@1312 := @1310 #15 +@1313 := LexLeanPreservation.Rust.fnIdent +@1314 := @1313 @1294 +@1321 := (hne : @1300) -> @1303 (fun (ro : @1302) => @1309 (@1312 @1314 @1286 @4)) +@1336 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {f : @35} -> + {fn : @1128} -> + {args : @147} -> + {env : @1238} -> + {F : @836} -> + {o : @1215} -> + (hB : @1246) -> + (hfn : @1262) -> (hwt : @1270) -> (hbind : @1282) -> (hF : @1292) -> (hA : @1298) -> @1321 +@1338 := LexLeanPreservation.Rust.compose @0 +@1339 := @1239 @0 +@1344 := (n : @35) -> @1339 @163 @157 @4 @149 +@1345 := @1255 @1130 +@1348 := @1248 (@1345 @149) @1261 +@1352 := @129 @1240 @163 @151 @1269 +@1353 := @1293 @0 +@1356 := @1353 @1263 @163 @151 +@1370 := {c : @33} -> + {A : @34} -> + {f : @35} -> + {fn : @1128} -> + {args : @147} -> + {env : @1238} -> + {F : @836} -> + {o : @1215} -> + (hB : @1344) -> + (hfn : @1348) -> (hwt : @1352) -> (hbind : @1282) -> (hF : @1292) -> (hA : @1356) -> @1321 +@1371 := @1338 @1 +@1372 := @1339 @1 +@1376 := (n : @35) -> @1372 @157 @4 @149 +@1379 := @137 @163 @151 @1269 +@1380 := @1285 @1 +@1383 := @1284 (@1380 @1240) @1291 +@1384 := @1310 @1 +@1394 := (hbind : @1282) -> + (hF : @1383) -> + (hA : @1356) -> (hne : @1300) -> @1303 (fun (ro : @1302) => @1309 (@1384 @1314 @1286 @4)) +@1404 := {A : @34} -> + {f : @35} -> + {fn : @1128} -> + {args : @147} -> + {env : @1238} -> + {F : @836} -> {o : @1215} -> (hB : @1376) -> (hfn : @1348) -> (hwt : @1379) -> @1394 +@1405 := @1371 @2 +@1407 := @1372 @2 @4 +@1409 := (n : @35) -> @1407 @149 +@1410 := @143 @151 +@1411 := @1410 @1269 +@1420 := {f : @35} -> + {fn : @1128} -> + {args : @147} -> + {env : @1238} -> + {F : @836} -> {o : @1215} -> (hB : @1409) -> (hfn : @1348) -> (hwt : @1411) -> @1394 +@1421 := @1405 @595 +@1423 := (n : @35) -> @1407 @595 +@1424 := @1345 @595 +@1425 := @1248 @1424 +@1426 := @1425 @1261 +@1427 := @1380 @595 +@1428 := @1284 @1427 +@1429 := @1428 @1291 +@1430 := @1353 @595 +@1432 := @1430 @163 @151 +@1434 := @1384 (@1313 @595) +@1442 := (hF : @1429) -> + (hA : @1432) -> (hne : @1300) -> @1303 (fun (ro : @1302) => @1309 (@1434 @1286 @4)) +@1451 := {fn : @1128} -> + {args : @147} -> + {env : @1238} -> + {F : @836} -> + {o : @1215} -> (hB : @1423) -> (hfn : @1426) -> (hwt : @1411) -> (hbind : @1282) -> @1442 +@1452 := @1421 @1146 +@1454 := @1425 (@1260 @1146) +@1455 := @1268 @1146 +@1456 := @1410 @1455 +@1458 := @1273 (@1274 @1146) +@1470 := {args : @147} -> + {env : @1238} -> + {F : @836} -> + {o : @1215} -> + (hB : @1423) -> + (hfn : @1454) -> (hwt : @1456) -> (hbind : @1272 (@1458 @149 @1123) @1281) -> @1442 +@1471 := @1452 @1114 +@1472 := @1156 @95 +@1474 := @143 @1472 @1455 +@1477 := @96 (@29 @157) @95 +@1481 := @1272 (@1458 @1477 @1123) @1281 +@1484 := @96 (@29 @1240) @95 +@1505 := {env : @1238} -> + {F : @836} -> + {o : @1215} -> + (hB : @1423) -> + (hfn : @1454) -> + (hwt : @1474) -> + (hbind : @1481) -> + (hF : @1429) -> + (hA : @1430 @1484 @151) -> + (hne : @1300) -> @1303 (fun (ro : @1302) => @1309 (@1434 (@96 (@29 #12) @95) @4)) +@1506 := @1471 @1126 +@1507 := @1170 @95 +@1509 := @143 @1507 @1455 +@1517 := @1272 (@1458 @1472 @1123) (@1280 (@1124 (@1121 @1155) @1123)) +@1520 := @96 (@29 @163) @95 +@1539 := {F : @836} -> + {o : @1215} -> + (hB : @1423) -> + (hfn : @1454) -> + (hwt : @1509) -> + (hbind : @1517) -> + (hF : @1429) -> + (hA : @1430 @1520 @151) -> + (hne : @1300) -> @1303 (fun (ro : @1302) => @1309 (@1434 (@96 (@29 @1286) @95) @4)) +@1540 := @1506 @1127 +@1541 := @1184 @1455 +@1549 := @1272 (@1458 @1507 @1123) (@1280 (@1124 (@1121 @1169) @1123)) +@1551 := @1428 (@1290 @1127) +@1553 := @1430 @1477 @151 +@1554 := @1305 @1127 +@1573 := {o : @1215} -> + (hB : @1423) -> + (hfn : @1454) -> + (hwt : @1541) -> + (hbind : @1549) -> + (hF : @1551) -> + (hA : @1553) -> + (hne : @1300) -> + @1303 (fun (ro : @1302) => @1304 (@1554 @163 @4) (@1434 (@96 (@29 @1263) @95) @4)) +@1574 := @1540 @1206 +@1575 := @1192 @1455 +@1583 := @1272 (@1458 @1183 @1123) (@1280 (@1124 (@1121 @1152) @1123)) +@1584 := @1430 @1472 +@1585 := @1205 @149 +@1586 := @1584 @1585 +@1587 := @1205 @157 +@1605 := (hB : @1423) -> + (hfn : @1454) -> + (hwt : @1575) -> + (hbind : @1583) -> + (hF : @1551) -> + (hA : @1586) -> + (hne : @1216 @1587 @1221) -> + @1303 (fun (ro : @1302) => @1304 (@1554 (@1205 @1240) @4) (@1434 @1484 @4)) +@1606 := @1574 @1150 +@1607 := @1199 @1455 +@1615 := @1272 (@1458 @1191 @1123) (@1280 (@1124 (@1121 @1166) @1123)) +@1616 := @1430 @1507 +@1617 := @1205 @151 +@1635 := (hfn : @1454) -> + (hwt : @1607) -> + (hbind : @1615) -> + (hF : @1551) -> + (hA : @1616 @1617) -> + (hne : @1216 @1585 @1221) -> + @1303 (fun (ro : @1302) => @1304 (@1554 (@1205 @163) @4) (@1434 @1520 @4)) +@1638 := @1606 (@705 @1247 @1424) +@1639 := @1203 @1455 +@1647 := @1272 (@1458 @1198 @1123) (@1280 (@1124 (@1121 @1179) @1123)) +@1648 := @1430 @1183 +@1649 := @1205 @153 +@1665 := (hwt : @1639) -> + (hbind : @1647) -> + (hF : @1551) -> + (hA : @1648 @1649) -> + (hne : @1216 @1617 @1221) -> @1303 (fun (ro : @1302) => @1304 (@1554 @1587 @4) (@1434 @1477 @4)) +@1666 := @1638 @1202 +@1668 := @1458 @1114 @1123 +@1671 := @1272 @1668 (@1280 @1126) +@1672 := @1430 @1191 +@1673 := @1205 @36 +@1688 := (hbind : @1671) -> + (hF : @1551) -> + (hA : @1672 @1673) -> + (hne : @1216 @1649 @1221) -> @1303 (fun (ro : @1302) => @1304 (@1554 @1585 @4) (@1434 @1472 @4)) +@1691 := @1666 (@705 @1271 @1668) +@1692 := @1430 @1198 +@1693 := @1205 @38 +@1707 := (hF : @1551) -> + (hA : @1692 @1693) -> + (hne : @1216 @1673 @1221) -> @1303 (fun (ro : @1302) => @1304 (@1554 @1617 @4) (@1434 @1507 @4)) +@1710 := @1691 (@705 @1283 @1427) +@1724 := (hA : @1430 @1114 @1206) -> + (hne : @1216 @1693 @1221) -> @1303 (fun (ro : @1302) => @1304 (@1554 @1649 @4) (@1434 @1183 @4)) +@1725 := @1710 @1213 +@1736 := (hne : @1216 @1206 @1221) -> + @1303 (fun (ro : @1302) => @1304 (@1554 @1673 @4) (@1434 @1191 @4)) +@1737 := @1725 @1233 +@1743 := @1304 (@1554 @1693 @4) (@1434 @1198 @4) +@1745 := @1303 (fun (ro : @1302) => @1743) +@1747 := @1303 (fun (__e_ro : @1302) => @1743) +@1751 := LexLeanPreservation.Rust.RepresentableL (@96 @42 @95) +@1752 := (__e_hrep : @1751) -> @1747 +@1753 := fun (__e_hrep : @1751) => @1737 +@1754 := (w : @35) -> @1752 +@1755 := fun (w : @35) => @1753 +\end{coremodule} +\end{lexlean} diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R5/Compose/RustCore.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R5/Compose/RustCore.lean deleted file mode 100644 index f784c09dd..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R5/Compose/RustCore.lean +++ /dev/null @@ -1,32 +0,0 @@ -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5 -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore - -theorem __wt_0 : ∀ (__s : (Reasoning.Clinic.Vitals)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.__enc_0 __s) (.adt 0) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).temperature) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).heartRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).respiratoryRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).whiteCells) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).systolic) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).infection) _root_.LexLeanPreservation.Rust.wtl_nil)))))) - -theorem __wt_1 : ∀ (__s : (Reasoning.Clinic.Chart)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.__enc_1 __s) (.adt 1) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 (__s).vitals) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).fever) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).tachycardia) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).tachypnea) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).leukocytosis) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).sirs) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).sepsis) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).shock) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).level) _root_.LexLeanPreservation.Rust.wtl_nil))))))))) - -theorem __wt_2 : ∀ (__v : (Reasoning.Main.Grade.Step)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.__enc_2 __v) (.adt 2) - | Reasoning.Main.Grade.Step.Fever => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Main.Grade.Step.Tachycardia => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Main.Grade.Step.Tachypnea => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Main.Grade.Step.Leukocytosis => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Main.Grade.Step.Sirs => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Main.Grade.Step.Sepsis => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Main.Grade.Step.Shock => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Main.Grade.Step.Escalate => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (temperature : Nat) (heartRate : Nat) (respiratoryRate : Nat) (whiteCells : Nat) (systolic : Nat) (infection : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.denote temperature heartRate respiratoryRate whiteCells systolic infection) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat temperature), (_root_.LexLeanTarget.TargetSyntax.Value.nat heartRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat respiratoryRate), (_root_.LexLeanTarget.TargetSyntax.Value.nat whiteCells), (_root_.LexLeanTarget.TargetSyntax.Value.nat systolic), (_root_.LexLeanTarget.TargetSyntax.Value.nat infection)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat temperature) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat heartRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat respiratoryRate) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat whiteCells) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat systolic) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat infection) _root_.LexLeanPreservation.Rust.wtl_nil)))))) rfl rfl (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.root temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R5/Compose/RustCore.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R5/Compose/RustCore.lex.tex new file mode 100644 index 000000000..7034ac05b --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R5/Compose/RustCore.lex.tex @@ -0,0 +1,1341 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5, + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_1 : @724 := @1388 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_2 : @1396 := @1631 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.root : @2716 := @2717 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.program +@1 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.krate +@2 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.flags +@3 := Reasoning.Clinic.Vitals +@4 := #0 +@5 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@16 := (__s : @3) -> @13 @6 @10 +@17 := Reasoning.Clinic.Vitals.temperature +@18 := @17 @4 +@19 := Reasoning.Clinic.Vitals.heartRate +@20 := @19 @4 +@21 := Reasoning.Clinic.Vitals.respiratoryRate +@22 := @21 @4 +@23 := Reasoning.Clinic.Vitals.whiteCells +@24 := @23 @4 +@25 := Reasoning.Clinic.Vitals.systolic +@26 := @25 @4 +@27 := Reasoning.Clinic.Vitals.infection +@28 := @27 @4 +@29 := LexLeanTarget.TargetSyntax.Value.nat +@30 := @29 @18 +@31 := LexLeanTarget.TargetSyntax.Ty.nat +@32 := LexLeanTarget.TargetSyntax.Program +@33 := LexLeanPreservation.Rust.RCrate +@34 := LexLeanPreservation.Rust.Flags +@35 := Nat +@36 := #3 +@37 := @7 @36 +@38 := #2 +@39 := @37 @38 +@40 := #1 +@41 := @39 @40 +@42 := @29 @4 +@48 := {p : @32} -> {c : @33} -> {A : @34} -> (n : @35) -> @41 @42 @31 +@50 := LexLeanPreservation.Rust.wt_nat @0 +@57 := {c : @33} -> {A : @34} -> (n : @35) -> @11 @38 @40 @42 @31 +@58 := @50 @1 +@63 := {A : @34} -> (n : @35) -> @12 @40 @42 @31 +@64 := @58 @2 +@67 := (n : @35) -> @13 @42 @31 +@68 := @64 @18 +@70 := @13 @30 @31 +@71 := @29 @20 +@72 := @64 @20 +@74 := @13 @71 @31 +@75 := @29 @22 +@76 := @64 @22 +@78 := @13 @75 @31 +@79 := @29 @24 +@80 := @64 @24 +@82 := @13 @79 @31 +@83 := @29 @26 +@84 := @64 @26 +@86 := @13 @83 @31 +@87 := @29 @28 +@88 := @64 @28 +@90 := @13 @87 @31 +@91 := LexLeanTarget.TargetSyntax.Value +@92 := LexLeanTarget.TargetSyntax.Ty +@93 := List.nil.{0} +@94 := List.cons.{0} +@95 := @93 @91 +@96 := @94 @91 +@98 := @96 @87 @95 +@100 := @96 @83 @98 +@102 := @96 @79 @100 +@104 := @96 @75 @102 +@106 := @96 @71 @104 +@108 := @96 @30 @106 +@109 := @93 @92 +@110 := @94 @92 +@111 := @110 @31 +@112 := @111 @109 +@113 := @111 @112 +@114 := @111 @113 +@115 := @111 @114 +@116 := @111 @115 +@117 := @111 @116 +@118 := LexLeanPreservation.Rust.WTL +@126 := {p : @32} -> {c : @33} -> {A : @34} -> @118 @38 @40 @4 @95 @109 +@128 := LexLeanPreservation.Rust.wtl_nil @0 +@129 := @118 @0 +@135 := {c : @33} -> {A : @34} -> @129 @40 @4 @95 @109 +@136 := @128 @1 +@137 := @129 @1 +@141 := {A : @34} -> @137 @4 @95 @109 +@142 := @136 @2 +@143 := @137 @2 +@144 := @143 @95 +@145 := @144 @109 +@146 := List.{0} +@147 := @146 @91 +@148 := @146 @92 +@149 := #6 +@150 := @7 @149 +@151 := #5 +@152 := @150 @151 +@153 := #4 +@156 := @152 @153 @36 @38 +@157 := #7 +@162 := @118 @157 @149 @151 @38 @40 +@163 := #8 +@166 := @118 @163 @157 @149 +@168 := @96 @151 @36 +@169 := @166 @168 +@171 := @110 @153 @38 +@181 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {v : @91} -> {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @156) -> (hs : @162) -> @169 @171 +@183 := LexLeanPreservation.Rust.wtl_cons @0 +@187 := @11 @151 @153 @36 @38 +@191 := @129 @149 @151 @38 @40 +@203 := {c : @33} -> + {A : @34} -> + {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @187) -> (hs : @191) -> @129 @157 @149 @168 @171 +@204 := @183 @1 +@207 := @12 @153 @36 @38 +@210 := @137 @151 @38 @40 +@220 := {A : @34} -> + {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @207) -> (hs : @210) -> @137 @149 @168 @171 +@221 := @204 @2 +@223 := @13 @36 @38 +@225 := @143 @38 @40 +@233 := {v : @91} -> + {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @223) -> (hs : @225) -> @143 @168 @171 +@234 := @221 @87 +@236 := @29 (@27 @36) +@249 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @236 @38) -> (hs : @225) -> @143 (@96 (@29 (@27 @151)) @36) @171 +@250 := @234 @31 +@252 := @29 (@27 @38) +@254 := @13 @252 @31 +@259 := @143 (@96 (@29 (@27 @153)) @36) +@260 := @111 @38 +@265 := {vs : @147} -> {ts : @148} -> (h : @254) -> (hs : @225) -> @259 @260 +@266 := @250 @95 +@268 := @29 (@27 @40) +@270 := @13 @268 @31 +@271 := @144 @40 +@273 := @96 @236 @95 +@278 := {ts : @148} -> (h : @270) -> (hs : @271) -> @143 @273 @260 +@279 := @266 @109 +@281 := @96 @252 @95 +@282 := @143 @281 +@285 := (h : @90) -> (hs : @145) -> @282 @112 +@286 := @279 @88 +@288 := @96 @268 @95 +@290 := @143 @288 @112 +@291 := (hs : @145) -> @290 +@292 := @286 @142 +@294 := @143 @98 @112 +@295 := @221 @83 +@297 := @29 (@25 @36) +@310 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @297 @38) -> (hs : @225) -> @143 (@96 (@29 (@25 @151)) @36) @171 +@311 := @295 @31 +@313 := @29 (@25 @38) +@325 := {vs : @147} -> + {ts : @148} -> (h : @13 @313 @31) -> (hs : @225) -> @143 (@96 (@29 (@25 @153)) @36) @260 +@326 := @311 @98 +@328 := @29 (@25 @40) +@330 := @13 @328 @31 +@331 := @282 @40 +@333 := @96 @297 @273 +@338 := {ts : @148} -> (h : @330) -> (hs : @331) -> @143 @333 @260 +@339 := @326 @112 +@341 := @96 @313 @281 +@342 := @143 @341 +@345 := (h : @86) -> (hs : @290) -> @342 @113 +@346 := @339 @84 +@348 := @96 @328 @288 +@350 := @143 @348 @113 +@351 := (hs : @294) -> @350 +@352 := @346 @292 +@354 := @143 @100 @113 +@355 := @221 @79 +@357 := @29 (@23 @36) +@370 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @357 @38) -> (hs : @225) -> @143 (@96 (@29 (@23 @151)) @36) @171 +@371 := @355 @31 +@373 := @29 (@23 @38) +@385 := {vs : @147} -> + {ts : @148} -> (h : @13 @373 @31) -> (hs : @225) -> @143 (@96 (@29 (@23 @153)) @36) @260 +@386 := @371 @100 +@388 := @29 (@23 @40) +@390 := @13 @388 @31 +@391 := @342 @40 +@393 := @96 @357 @333 +@398 := {ts : @148} -> (h : @390) -> (hs : @391) -> @143 @393 @260 +@399 := @386 @113 +@401 := @96 @373 @341 +@402 := @143 @401 +@405 := (h : @82) -> (hs : @350) -> @402 @114 +@406 := @399 @80 +@408 := @96 @388 @348 +@410 := @143 @408 @114 +@411 := (hs : @354) -> @410 +@412 := @406 @352 +@414 := @143 @102 @114 +@415 := @221 @75 +@417 := @29 (@21 @36) +@430 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @417 @38) -> (hs : @225) -> @143 (@96 (@29 (@21 @151)) @36) @171 +@431 := @415 @31 +@433 := @29 (@21 @38) +@445 := {vs : @147} -> + {ts : @148} -> (h : @13 @433 @31) -> (hs : @225) -> @143 (@96 (@29 (@21 @153)) @36) @260 +@446 := @431 @102 +@448 := @29 (@21 @40) +@450 := @13 @448 @31 +@451 := @402 @40 +@453 := @96 @417 @393 +@458 := {ts : @148} -> (h : @450) -> (hs : @451) -> @143 @453 @260 +@459 := @446 @114 +@461 := @96 @433 @401 +@462 := @143 @461 +@465 := (h : @78) -> (hs : @410) -> @462 @115 +@466 := @459 @76 +@468 := @96 @448 @408 +@470 := @143 @468 @115 +@471 := (hs : @414) -> @470 +@472 := @466 @412 +@474 := @143 @104 @115 +@475 := @221 @71 +@477 := @29 (@19 @36) +@490 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @477 @38) -> (hs : @225) -> @143 (@96 (@29 (@19 @151)) @36) @171 +@491 := @475 @31 +@493 := @29 (@19 @38) +@505 := {vs : @147} -> + {ts : @148} -> (h : @13 @493 @31) -> (hs : @225) -> @143 (@96 (@29 (@19 @153)) @36) @260 +@506 := @491 @104 +@508 := @29 (@19 @40) +@510 := @13 @508 @31 +@511 := @462 @40 +@513 := @96 @477 @453 +@518 := {ts : @148} -> (h : @510) -> (hs : @511) -> @143 @513 @260 +@519 := @506 @115 +@521 := @96 @493 @461 +@522 := @143 @521 +@525 := (h : @74) -> (hs : @470) -> @522 @116 +@526 := @519 @72 +@528 := @96 @508 @468 +@530 := @143 @528 @116 +@531 := (hs : @474) -> @530 +@532 := @526 @472 +@534 := @143 @106 @116 +@535 := @221 @30 +@537 := @29 (@17 @36) +@550 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @537 @38) -> (hs : @225) -> @143 (@96 (@29 (@17 @151)) @36) @171 +@551 := @535 @31 +@553 := @29 (@17 @38) +@565 := {vs : @147} -> + {ts : @148} -> (h : @13 @553 @31) -> (hs : @225) -> @143 (@96 (@29 (@17 @153)) @36) @260 +@566 := @551 @106 +@568 := @29 (@17 @40) +@570 := @13 @568 @31 +@571 := @522 @40 +@573 := @96 @537 @513 +@578 := {ts : @148} -> (h : @570) -> (hs : @571) -> @143 @573 @260 +@579 := @566 @116 +@581 := @96 @553 @521 +@582 := @143 @581 +@585 := (h : @70) -> (hs : @530) -> @582 @117 +@586 := @579 @68 +@588 := @96 @568 @528 +@590 := @143 @588 @117 +@591 := (hs : @534) -> @590 +@592 := @586 @532 +@594 := @143 @108 @117 +@595 := Eq.{1} +@596 := Option.{0} +@597 := @596 @148 +@598 := @595 @597 +@599 := LexLeanPreservation.Rust.adtFields +@603 := @598 (@599 @149 @36 @38) +@604 := Option.some.{0} +@605 := @604 @148 +@606 := @605 @4 +@607 := @603 @606 +@610 := @7 @163 @157 @149 +@611 := LexLeanTarget.TargetSyntax.Value.adt +@613 := @611 @153 @36 +@614 := @610 @613 +@615 := @8 @151 +@625 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {i : @35} -> {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @607) -> (hf : @162) -> @614 @615 +@627 := LexLeanPreservation.Rust.wt_adt @0 +@628 := @599 @0 +@632 := @598 (@628 @36 @38) @606 +@644 := {c : @33} -> + {A : @34} -> + {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @191) -> @11 @157 @149 @613 @615 +@645 := @627 @1 +@655 := {A : @34} -> + {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @210) -> @12 @149 @613 @615 +@656 := @645 @2 +@657 := @13 @613 +@664 := {i : @35} -> + {k : @35} -> {fs : @147} -> {tys : @148} -> (h : @632) -> (hf : @225) -> @657 @615 +@665 := @656 @9 +@666 := @628 @9 +@675 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@666 @38) @606) -> (hf : @225) -> @657 @10 +@676 := @665 @9 +@677 := @666 @9 +@678 := @598 @677 +@679 := @678 @606 +@680 := @611 @9 +@682 := @13 (@680 @36) +@687 := {fs : @147} -> {tys : @148} -> (h : @679) -> (hf : @225) -> @682 @10 +@688 := @676 @108 +@695 := {tys : @148} -> (h : @679) -> (hf : @582 @40) -> @13 (@680 @573) @10 +@696 := @688 @117 +@703 := (h : @678 (@605 @117)) -> (hf : @590) -> @13 (@680 @581) @10 +@704 := Eq.refl.{1} +@705 := @704 @597 +@707 := @696 (@705 @677) +@711 := (hf : @594) -> @13 (@680 @588) @10 +@712 := @707 @592 +@715 := @13 (@680 @108) @10 +@716 := fun (__s : @3) => @712 +@717 := Reasoning.Clinic.Chart +@719 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.__enc_1 @4 +@720 := 1 +@721 := @8 @720 +@724 := (__s : @717) -> @13 @719 @721 +@725 := Reasoning.Clinic.Chart.vitals +@726 := @725 @4 +@727 := Reasoning.Clinic.Chart.fever +@728 := @727 @4 +@729 := Reasoning.Clinic.Chart.tachycardia +@730 := @729 @4 +@731 := Reasoning.Clinic.Chart.tachypnea +@732 := @731 @4 +@733 := Reasoning.Clinic.Chart.leukocytosis +@734 := @733 @4 +@735 := Reasoning.Clinic.Chart.sirs +@736 := @735 @4 +@737 := Reasoning.Clinic.Chart.sepsis +@738 := @737 @4 +@739 := Reasoning.Clinic.Chart.shock +@740 := @739 @4 +@741 := Reasoning.Clinic.Chart.level +@742 := @741 @4 +@743 := @5 @726 +@745 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_0 @726 +@746 := @29 @728 +@747 := @64 @728 +@749 := @13 @746 @31 +@750 := @29 @730 +@751 := @64 @730 +@753 := @13 @750 @31 +@754 := @29 @732 +@755 := @64 @732 +@757 := @13 @754 @31 +@758 := @29 @734 +@759 := @64 @734 +@761 := @13 @758 @31 +@762 := @29 @736 +@763 := @64 @736 +@765 := @13 @762 @31 +@766 := @29 @738 +@767 := @64 @738 +@769 := @13 @766 @31 +@770 := @29 @740 +@771 := @64 @740 +@773 := @13 @770 @31 +@774 := @29 @742 +@775 := @64 @742 +@777 := @13 @774 @31 +@779 := @96 @774 @95 +@781 := @96 @770 @779 +@783 := @96 @766 @781 +@785 := @96 @762 @783 +@787 := @96 @758 @785 +@789 := @96 @754 @787 +@791 := @96 @750 @789 +@793 := @96 @746 @791 +@795 := @96 @743 @793 +@796 := @111 @117 +@797 := @111 @796 +@798 := @110 @10 +@799 := @798 @797 +@800 := @221 @774 +@802 := @29 (@741 @36) +@815 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @802 @38) -> (hs : @225) -> @143 (@96 (@29 (@741 @151)) @36) @171 +@816 := @800 @31 +@818 := @29 (@741 @38) +@830 := {vs : @147} -> + {ts : @148} -> (h : @13 @818 @31) -> (hs : @225) -> @143 (@96 (@29 (@741 @153)) @36) @260 +@831 := @816 @95 +@833 := @29 (@741 @40) +@835 := @13 @833 @31 +@837 := @96 @802 @95 +@842 := {ts : @148} -> (h : @835) -> (hs : @271) -> @143 @837 @260 +@843 := @831 @109 +@845 := @96 @818 @95 +@846 := @143 @845 +@849 := (h : @777) -> (hs : @145) -> @846 @112 +@850 := @843 @775 +@852 := @96 @833 @95 +@854 := @143 @852 @112 +@855 := (hs : @145) -> @854 +@856 := @850 @142 +@858 := @143 @779 @112 +@859 := @221 @770 +@861 := @29 (@739 @36) +@874 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @861 @38) -> (hs : @225) -> @143 (@96 (@29 (@739 @151)) @36) @171 +@875 := @859 @31 +@877 := @29 (@739 @38) +@889 := {vs : @147} -> + {ts : @148} -> (h : @13 @877 @31) -> (hs : @225) -> @143 (@96 (@29 (@739 @153)) @36) @260 +@890 := @875 @779 +@892 := @29 (@739 @40) +@894 := @13 @892 @31 +@895 := @846 @40 +@897 := @96 @861 @837 +@902 := {ts : @148} -> (h : @894) -> (hs : @895) -> @143 @897 @260 +@903 := @890 @112 +@905 := @96 @877 @845 +@906 := @143 @905 +@909 := (h : @773) -> (hs : @854) -> @906 @113 +@910 := @903 @771 +@912 := @96 @892 @852 +@914 := @143 @912 @113 +@915 := (hs : @858) -> @914 +@916 := @910 @856 +@918 := @143 @781 @113 +@919 := @221 @766 +@921 := @29 (@737 @36) +@934 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @921 @38) -> (hs : @225) -> @143 (@96 (@29 (@737 @151)) @36) @171 +@935 := @919 @31 +@937 := @29 (@737 @38) +@949 := {vs : @147} -> + {ts : @148} -> (h : @13 @937 @31) -> (hs : @225) -> @143 (@96 (@29 (@737 @153)) @36) @260 +@950 := @935 @781 +@952 := @29 (@737 @40) +@954 := @13 @952 @31 +@955 := @906 @40 +@957 := @96 @921 @897 +@962 := {ts : @148} -> (h : @954) -> (hs : @955) -> @143 @957 @260 +@963 := @950 @113 +@965 := @96 @937 @905 +@966 := @143 @965 +@969 := (h : @769) -> (hs : @914) -> @966 @114 +@970 := @963 @767 +@972 := @96 @952 @912 +@974 := @143 @972 @114 +@975 := (hs : @918) -> @974 +@976 := @970 @916 +@978 := @143 @783 @114 +@979 := @221 @762 +@981 := @29 (@735 @36) +@994 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @981 @38) -> (hs : @225) -> @143 (@96 (@29 (@735 @151)) @36) @171 +@995 := @979 @31 +@997 := @29 (@735 @38) +@1009 := {vs : @147} -> + {ts : @148} -> (h : @13 @997 @31) -> (hs : @225) -> @143 (@96 (@29 (@735 @153)) @36) @260 +@1010 := @995 @783 +@1012 := @29 (@735 @40) +@1014 := @13 @1012 @31 +@1015 := @966 @40 +@1017 := @96 @981 @957 +@1022 := {ts : @148} -> (h : @1014) -> (hs : @1015) -> @143 @1017 @260 +@1023 := @1010 @114 +@1025 := @96 @997 @965 +@1026 := @143 @1025 +@1029 := (h : @765) -> (hs : @974) -> @1026 @115 +@1030 := @1023 @763 +@1032 := @96 @1012 @972 +@1034 := @143 @1032 @115 +@1035 := (hs : @978) -> @1034 +@1036 := @1030 @976 +@1038 := @143 @785 @115 +@1039 := @221 @758 +@1041 := @29 (@733 @36) +@1054 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1041 @38) -> (hs : @225) -> @143 (@96 (@29 (@733 @151)) @36) @171 +@1055 := @1039 @31 +@1057 := @29 (@733 @38) +@1069 := {vs : @147} -> + {ts : @148} -> (h : @13 @1057 @31) -> (hs : @225) -> @143 (@96 (@29 (@733 @153)) @36) @260 +@1070 := @1055 @785 +@1072 := @29 (@733 @40) +@1074 := @13 @1072 @31 +@1075 := @1026 @40 +@1077 := @96 @1041 @1017 +@1082 := {ts : @148} -> (h : @1074) -> (hs : @1075) -> @143 @1077 @260 +@1083 := @1070 @115 +@1085 := @96 @1057 @1025 +@1086 := @143 @1085 +@1089 := (h : @761) -> (hs : @1034) -> @1086 @116 +@1090 := @1083 @759 +@1092 := @96 @1072 @1032 +@1094 := @143 @1092 @116 +@1095 := (hs : @1038) -> @1094 +@1096 := @1090 @1036 +@1098 := @143 @787 @116 +@1099 := @221 @754 +@1101 := @29 (@731 @36) +@1114 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1101 @38) -> (hs : @225) -> @143 (@96 (@29 (@731 @151)) @36) @171 +@1115 := @1099 @31 +@1117 := @29 (@731 @38) +@1129 := {vs : @147} -> + {ts : @148} -> (h : @13 @1117 @31) -> (hs : @225) -> @143 (@96 (@29 (@731 @153)) @36) @260 +@1130 := @1115 @787 +@1132 := @29 (@731 @40) +@1134 := @13 @1132 @31 +@1135 := @1086 @40 +@1137 := @96 @1101 @1077 +@1142 := {ts : @148} -> (h : @1134) -> (hs : @1135) -> @143 @1137 @260 +@1143 := @1130 @116 +@1145 := @96 @1117 @1085 +@1146 := @143 @1145 +@1149 := (h : @757) -> (hs : @1094) -> @1146 @117 +@1150 := @1143 @755 +@1152 := @96 @1132 @1092 +@1154 := @143 @1152 @117 +@1155 := (hs : @1098) -> @1154 +@1156 := @1150 @1096 +@1158 := @143 @789 @117 +@1159 := @221 @750 +@1161 := @29 (@729 @36) +@1174 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1161 @38) -> (hs : @225) -> @143 (@96 (@29 (@729 @151)) @36) @171 +@1175 := @1159 @31 +@1177 := @29 (@729 @38) +@1189 := {vs : @147} -> + {ts : @148} -> (h : @13 @1177 @31) -> (hs : @225) -> @143 (@96 (@29 (@729 @153)) @36) @260 +@1190 := @1175 @789 +@1192 := @29 (@729 @40) +@1194 := @13 @1192 @31 +@1195 := @1146 @40 +@1197 := @96 @1161 @1137 +@1202 := {ts : @148} -> (h : @1194) -> (hs : @1195) -> @143 @1197 @260 +@1203 := @1190 @117 +@1205 := @96 @1177 @1145 +@1206 := @143 @1205 +@1209 := (h : @753) -> (hs : @1154) -> @1206 @796 +@1210 := @1203 @751 +@1212 := @96 @1192 @1152 +@1214 := @143 @1212 @796 +@1215 := (hs : @1158) -> @1214 +@1216 := @1210 @1156 +@1218 := @143 @791 @796 +@1219 := @221 @746 +@1221 := @29 (@727 @36) +@1234 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1221 @38) -> (hs : @225) -> @143 (@96 (@29 (@727 @151)) @36) @171 +@1235 := @1219 @31 +@1237 := @29 (@727 @38) +@1249 := {vs : @147} -> + {ts : @148} -> (h : @13 @1237 @31) -> (hs : @225) -> @143 (@96 (@29 (@727 @153)) @36) @260 +@1250 := @1235 @791 +@1252 := @29 (@727 @40) +@1254 := @13 @1252 @31 +@1255 := @1206 @40 +@1257 := @96 @1221 @1197 +@1262 := {ts : @148} -> (h : @1254) -> (hs : @1255) -> @143 @1257 @260 +@1263 := @1250 @796 +@1265 := @96 @1237 @1205 +@1266 := @143 @1265 +@1269 := (h : @749) -> (hs : @1214) -> @1266 @797 +@1270 := @1263 @747 +@1272 := @96 @1252 @1212 +@1274 := @143 @1272 @797 +@1275 := (hs : @1218) -> @1274 +@1276 := @1270 @1216 +@1278 := @143 @793 @797 +@1279 := @221 @743 +@1281 := @5 (@725 @36) +@1294 := {t : @92} -> + {vs : @147} -> + {ts : @148} -> (h : @13 @1281 @38) -> (hs : @225) -> @143 (@96 (@5 (@725 @151)) @36) @171 +@1295 := @1279 @10 +@1297 := @5 (@725 @38) +@1299 := @13 @1297 @10 +@1304 := @143 (@96 (@5 (@725 @153)) @36) +@1305 := @798 @38 +@1310 := {vs : @147} -> {ts : @148} -> (h : @1299) -> (hs : @225) -> @1304 @1305 +@1311 := @1295 @793 +@1313 := @5 (@725 @40) +@1315 := @13 @1313 @10 +@1316 := @1266 @40 +@1318 := @96 @1281 @1257 +@1323 := {ts : @148} -> (h : @1315) -> (hs : @1316) -> @143 @1318 @1305 +@1324 := @1311 @797 +@1326 := @13 @743 @10 +@1328 := @96 @1297 @1265 +@1329 := @143 @1328 +@1332 := (h : @1326) -> (hs : @1274) -> @1329 @799 +@1333 := @1324 @745 +@1335 := @96 @1313 @1272 +@1337 := @143 @1335 @799 +@1338 := (hs : @1278) -> @1337 +@1339 := @1333 @1276 +@1341 := @143 @795 @799 +@1342 := @656 @720 +@1343 := @628 @720 +@1352 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@1343 @38) @606) -> (hf : @225) -> @657 @721 +@1353 := @1342 @9 +@1354 := @1343 @9 +@1355 := @598 @1354 +@1356 := @1355 @606 +@1361 := {fs : @147} -> {tys : @148} -> (h : @1356) -> (hf : @225) -> @682 @721 +@1362 := @1353 @795 +@1369 := {tys : @148} -> (h : @1356) -> (hf : @1329 @40) -> @13 (@680 @1318) @721 +@1370 := @1362 @799 +@1377 := (h : @1355 (@605 @799)) -> (hf : @1337) -> @13 (@680 @1328) @721 +@1379 := @1370 (@705 @1354) +@1383 := (hf : @1341) -> @13 (@680 @1335) @721 +@1384 := @1379 @1339 +@1387 := @13 (@680 @795) @721 +@1388 := fun (__s : @717) => @1384 +@1389 := Reasoning.Main.Grade.Step +@1391 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.__enc_2 @4 +@1392 := 2 +@1393 := @8 @1392 +@1395 := @13 @1391 @1393 +@1396 := (__v : @1389) -> @1395 +@1397 := fun (__v : @1389) => @1395 +@1398 := @656 @1392 +@1399 := @628 @1392 +@1408 := {k : @35} -> + {fs : @147} -> {tys : @148} -> (h : @598 (@1399 @38) @606) -> (hf : @225) -> @657 @1393 +@1409 := @1398 @9 +@1410 := @1399 @9 +@1411 := @598 @1410 +@1412 := @1411 @606 +@1417 := {fs : @147} -> {tys : @148} -> (h : @1412) -> (hf : @225) -> @682 @1393 +@1418 := @1409 @95 +@1421 := @13 (@680 @95) @1393 +@1424 := {tys : @148} -> (h : @1412) -> (hf : @271) -> @1421 +@1425 := @1418 @109 +@1426 := @605 @109 +@1429 := (h : @1411 @1426) -> (hf : @145) -> @1421 +@1432 := @1425 (@705 @1410) @142 +@1433 := @1398 @720 +@1434 := @1399 @720 +@1435 := @598 @1434 +@1436 := @1435 @606 +@1437 := @611 @720 +@1444 := {fs : @147} -> {tys : @148} -> (h : @1436) -> (hf : @225) -> @13 (@1437 @36) @1393 +@1445 := @1433 @95 +@1448 := @13 (@1437 @95) @1393 +@1451 := {tys : @148} -> (h : @1436) -> (hf : @271) -> @1448 +@1452 := @1445 @109 +@1455 := (h : @1435 @1426) -> (hf : @145) -> @1448 +@1458 := @1452 (@705 @1434) @142 +@1459 := @1398 @1392 +@1460 := @1399 @1392 +@1461 := @598 @1460 +@1462 := @1461 @606 +@1463 := @611 @1392 +@1470 := {fs : @147} -> {tys : @148} -> (h : @1462) -> (hf : @225) -> @13 (@1463 @36) @1393 +@1471 := @1459 @95 +@1474 := @13 (@1463 @95) @1393 +@1477 := {tys : @148} -> (h : @1462) -> (hf : @271) -> @1474 +@1478 := @1471 @109 +@1481 := (h : @1461 @1426) -> (hf : @145) -> @1474 +@1484 := @1478 (@705 @1460) @142 +@1485 := 3 +@1486 := @1398 @1485 +@1487 := @1399 @1485 +@1488 := @598 @1487 +@1489 := @1488 @606 +@1490 := @611 @1485 +@1497 := {fs : @147} -> {tys : @148} -> (h : @1489) -> (hf : @225) -> @13 (@1490 @36) @1393 +@1498 := @1486 @95 +@1501 := @13 (@1490 @95) @1393 +@1504 := {tys : @148} -> (h : @1489) -> (hf : @271) -> @1501 +@1505 := @1498 @109 +@1508 := (h : @1488 @1426) -> (hf : @145) -> @1501 +@1511 := @1505 (@705 @1487) @142 +@1512 := 4 +@1513 := @1398 @1512 +@1514 := @1399 @1512 +@1515 := @598 @1514 +@1516 := @1515 @606 +@1517 := @611 @1512 +@1524 := {fs : @147} -> {tys : @148} -> (h : @1516) -> (hf : @225) -> @13 (@1517 @36) @1393 +@1525 := @1513 @95 +@1528 := @13 (@1517 @95) @1393 +@1531 := {tys : @148} -> (h : @1516) -> (hf : @271) -> @1528 +@1532 := @1525 @109 +@1535 := (h : @1515 @1426) -> (hf : @145) -> @1528 +@1538 := @1532 (@705 @1514) @142 +@1539 := 5 +@1540 := @1398 @1539 +@1541 := @1399 @1539 +@1542 := @598 @1541 +@1543 := @1542 @606 +@1544 := @611 @1539 +@1551 := {fs : @147} -> {tys : @148} -> (h : @1543) -> (hf : @225) -> @13 (@1544 @36) @1393 +@1552 := @1540 @95 +@1555 := @13 (@1544 @95) @1393 +@1558 := {tys : @148} -> (h : @1543) -> (hf : @271) -> @1555 +@1559 := @1552 @109 +@1562 := (h : @1542 @1426) -> (hf : @145) -> @1555 +@1565 := @1559 (@705 @1541) @142 +@1566 := 6 +@1567 := @1398 @1566 +@1568 := @1399 @1566 +@1569 := @598 @1568 +@1570 := @1569 @606 +@1571 := @611 @1566 +@1578 := {fs : @147} -> {tys : @148} -> (h : @1570) -> (hf : @225) -> @13 (@1571 @36) @1393 +@1579 := @1567 @95 +@1582 := @13 (@1571 @95) @1393 +@1585 := {tys : @148} -> (h : @1570) -> (hf : @271) -> @1582 +@1586 := @1579 @109 +@1589 := (h : @1569 @1426) -> (hf : @145) -> @1582 +@1592 := @1586 (@705 @1568) @142 +@1593 := 7 +@1594 := @1398 @1593 +@1595 := @1399 @1593 +@1596 := @598 @1595 +@1597 := @1596 @606 +@1598 := @611 @1593 +@1605 := {fs : @147} -> {tys : @148} -> (h : @1597) -> (hf : @225) -> @13 (@1598 @36) @1393 +@1606 := @1594 @95 +@1609 := @13 (@1598 @95) @1393 +@1612 := {tys : @148} -> (h : @1597) -> (hf : @271) -> @1609 +@1613 := @1606 @109 +@1616 := (h : @1596 @1426) -> (hf : @145) -> @1609 +@1619 := @1613 (@705 @1595) @142 +@1631 := fun (__v : @1389) => + Reasoning.Main.Grade.Step.casesOn.{0} @1397 @4 @1432 @1458 @1484 @1511 @1538 @1565 @1592 @1619 +@1632 := @29 @149 +@1633 := @64 @149 +@1634 := @13 @1632 +@1635 := @1634 @31 +@1636 := @29 @151 +@1637 := @64 @151 +@1638 := @13 @1636 +@1639 := @1638 @31 +@1640 := @29 @153 +@1641 := @64 @153 +@1642 := @13 @1640 +@1643 := @1642 @31 +@1644 := @29 @36 +@1645 := @64 @36 +@1647 := @13 @1644 @31 +@1648 := @29 @38 +@1649 := @64 @38 +@1651 := @13 @1648 @31 +@1652 := @29 @40 +@1653 := @64 @40 +@1655 := @13 @1652 @31 +@1656 := @96 @1652 +@1657 := @1656 @95 +@1658 := @96 @1648 +@1659 := @1658 @1657 +@1660 := @96 @1644 +@1661 := @1660 @1659 +@1662 := @96 @1640 +@1663 := @1662 @1661 +@1664 := @96 @1636 +@1665 := @1664 @1663 +@1666 := @96 @1632 +@1667 := @1666 @1665 +@1670 := Prod.{0, 0} @35 @91 +@1673 := Prod.mk.{0, 0} @35 @91 +@1674 := @1673 @1539 +@1675 := @1674 @1652 +@1676 := @1673 @1512 +@1677 := @1676 @1648 +@1678 := @1673 @1485 +@1679 := @1678 @1644 +@1680 := @1673 @1392 +@1681 := @1680 @1640 +@1682 := @1673 @720 +@1683 := @1682 @1636 +@1684 := @1673 @9 +@1685 := @1684 @1632 +@1686 := @93 @1670 +@1687 := @94 @1670 +@1689 := @1687 @1685 @1686 +@1691 := @1687 @1683 @1689 +@1693 := @1687 @1681 @1691 +@1695 := @1687 @1679 @1693 +@1697 := @1687 @1677 @1695 +@1699 := @1687 @1675 @1697 +@1700 := Bool.true +@1701 := LexLeanTarget.TargetSyntax.Function +@1702 := LexLeanTarget.TargetSyntax.Program.functions +@1703 := @1702 @0 +@1704 := @93 @35 +@1705 := LexLeanTarget.TargetSyntax.Ty.unit +@1706 := LexLeanTarget.TargetSyntax.Value.unit +@1709 := LexLeanTarget.TargetSyntax.Expr.value @1705 @1706 +@1714 := LexLeanTarget.TargetSyntax.Function.mk @1704 @109 @1705 @1709 +@1719 := List.getD.{0} @1701 @1703 @9 @1714 +@1723 := fun (__e_n : @35) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.root @4 @9 +@1724 := @221 @1652 +@1725 := @1642 @38 +@1727 := @143 (@1666 @36) +@1733 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1725) -> (hs : @225) -> @1727 @171 +@1734 := @1724 @31 +@1741 := {vs : @147} -> {ts : @148} -> (h : @1647) -> (hs : @225) -> @143 (@1664 @36) @260 +@1742 := @1734 @95 +@1743 := @1662 @95 +@1748 := {ts : @148} -> (h : @1651) -> (hs : @271) -> @143 @1743 @260 +@1749 := @1742 @109 +@1750 := @1660 @95 +@1751 := @143 @1750 +@1754 := (h : @1655) -> (hs : @145) -> @1751 @112 +@1755 := @1749 @1653 +@1756 := @1658 @95 +@1758 := @143 @1756 @112 +@1759 := (hs : @145) -> @1758 +@1760 := @1755 @142 +@1762 := @143 @1657 @112 +@1763 := @221 @1648 +@1764 := @1638 @38 +@1765 := @29 @157 +@1766 := @96 @1765 +@1768 := @143 (@1766 @36) +@1774 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1764) -> (hs : @225) -> @1768 @171 +@1775 := @1763 @31 +@1780 := {vs : @147} -> {ts : @148} -> (h : @1643) -> (hs : @225) -> @1727 @260 +@1781 := @1775 @1657 +@1782 := @1751 @40 +@1783 := @1664 @1743 +@1788 := {ts : @148} -> (h : @1647) -> (hs : @1782) -> @143 @1783 @260 +@1789 := @1781 @112 +@1790 := @1662 @1750 +@1791 := @143 @1790 +@1794 := (h : @1651) -> (hs : @1758) -> @1791 @113 +@1795 := @1789 @1649 +@1796 := @1660 @1756 +@1798 := @143 @1796 @113 +@1799 := (hs : @1762) -> @1798 +@1800 := @1795 @1760 +@1802 := @143 @1659 @113 +@1803 := @221 @1644 +@1804 := @1634 @38 +@1805 := @29 @163 +@1806 := @96 @1805 +@1808 := @143 (@1806 @36) +@1814 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1804) -> (hs : @225) -> @1808 @171 +@1815 := @1803 @31 +@1820 := {vs : @147} -> {ts : @148} -> (h : @1639) -> (hs : @225) -> @1768 @260 +@1821 := @1815 @1659 +@1822 := @1791 @40 +@1823 := @1666 @1783 +@1828 := {ts : @148} -> (h : @1643) -> (hs : @1822) -> @143 @1823 @260 +@1829 := @1821 @113 +@1830 := @1664 @1790 +@1831 := @143 @1830 +@1834 := (h : @1647) -> (hs : @1798) -> @1831 @114 +@1835 := @1829 @1645 +@1836 := @1662 @1796 +@1838 := @143 @1836 @114 +@1839 := (hs : @1802) -> @1838 +@1840 := @1835 @1800 +@1842 := @143 @1661 @114 +@1843 := @221 @1640 +@1844 := @13 @1765 +@1845 := @1844 @38 +@1846 := #9 +@1847 := @29 @1846 +@1848 := @96 @1847 +@1850 := @143 (@1848 @36) +@1856 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1845) -> (hs : @225) -> @1850 @171 +@1857 := @1843 @31 +@1862 := {vs : @147} -> {ts : @148} -> (h : @1635) -> (hs : @225) -> @1808 @260 +@1863 := @1857 @1661 +@1864 := @1831 @40 +@1865 := @1766 @1823 +@1870 := {ts : @148} -> (h : @1639) -> (hs : @1864) -> @143 @1865 @260 +@1871 := @1863 @114 +@1872 := @1666 @1830 +@1873 := @143 @1872 +@1876 := (h : @1643) -> (hs : @1838) -> @1873 @115 +@1877 := @1871 @1641 +@1878 := @1664 @1836 +@1880 := @143 @1878 @115 +@1881 := (hs : @1842) -> @1880 +@1882 := @1877 @1840 +@1884 := @143 @1663 @115 +@1885 := @221 @1636 +@1886 := @13 @1805 +@1887 := @1886 @38 +@1888 := #10 +@1889 := @29 @1888 +@1890 := @96 @1889 +@1892 := @143 (@1890 @36) +@1898 := {t : @92} -> {vs : @147} -> {ts : @148} -> (h : @1887) -> (hs : @225) -> @1892 @171 +@1899 := @1885 @31 +@1900 := @1844 @31 +@1905 := {vs : @147} -> {ts : @148} -> (h : @1900) -> (hs : @225) -> @1850 @260 +@1906 := @1899 @1663 +@1907 := @1873 @40 +@1908 := @1806 @1865 +@1913 := {ts : @148} -> (h : @1635) -> (hs : @1907) -> @143 @1908 @260 +@1914 := @1906 @115 +@1915 := @1766 @1872 +@1916 := @143 @1915 +@1919 := (h : @1639) -> (hs : @1880) -> @1916 @116 +@1920 := @1914 @1637 +@1921 := @1666 @1878 +@1923 := @143 @1921 @116 +@1924 := (hs : @1884) -> @1923 +@1925 := @1920 @1882 +@1927 := @143 @1665 @116 +@1928 := @221 @1632 +@1930 := @13 @1847 @38 +@1931 := #11 +@1932 := @29 @1931 +@1933 := @96 @1932 +@1941 := {t : @92} -> + {vs : @147} -> {ts : @148} -> (h : @1930) -> (hs : @225) -> @143 (@1933 @36) @171 +@1942 := @1928 @31 +@1948 := {vs : @147} -> {ts : @148} -> (h : @1886 @31) -> (hs : @225) -> @1892 @260 +@1949 := @1942 @1665 +@1950 := @1916 @40 +@1951 := @1848 @1908 +@1952 := @143 @1951 +@1956 := {ts : @148} -> (h : @1900) -> (hs : @1950) -> @1952 @260 +@1957 := @1949 @116 +@1958 := @1806 @1915 +@1959 := @143 @1958 +@1962 := (h : @1635) -> (hs : @1923) -> @1959 @117 +@1963 := @1957 @1633 +@1964 := @1766 @1921 +@1965 := @143 @1964 +@1967 := (hs : @1927) -> @1965 @117 +@1968 := @1963 @1925 +@1969 := @143 @1667 +@1970 := @1969 @117 +@1971 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.denote +@1977 := @1971 @149 @151 @153 @36 @38 @40 +@1978 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.__fits_0 +@1984 := @1978 @149 @151 @153 @36 @38 @40 +@1992 := @29 (Reasoning.Main.gradeLevel @149 @151 @153 @36 @38 @40) +@1999 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.root @149 @151 @153 @36 @38 @40 +@2000 := Bool +@2001 := Ne.{1} +@2002 := LexLeanPreservation.Obs +@2003 := @2001 @2002 +@2004 := LexLeanPreservation.Rel +@2007 := @2003 (@2004 @40 @4) +@2008 := LexLeanPreservation.Obs.stuck +@2011 := (f : @2000) -> (v : @91) -> @2007 @2008 +@2013 := LexLeanPreservation.Rust.rel_ne_stuck @1984 +@2024 := (v : @91) -> @2003 (@2004 (@1978 @157 @149 @151 @153 @36 @38) @4) @2008 +@2025 := @2013 @1992 +@2029 := @2003 (@2004 @1984 @1992) @2008 +@2030 := @146 @1670 +@2031 := LexLeanPreservation.Rust.FunSem +@2037 := (n : @35) -> @2031 @1846 @163 @157 @4 @149 +@2038 := @596 @1701 +@2039 := @595 @2038 +@2046 := LexLeanRuntime.index (@146 @1701) @1701 (LexLeanRuntime.instIndexableList @1701) +@2050 := @2039 (@2046 (@1702 @1846) @149) +@2051 := @604 @1701 +@2052 := @2051 @151 +@2053 := @2050 @2052 +@2057 := @118 @1888 @1846 @163 @151 +@2058 := LexLeanTarget.TargetSyntax.Function.types +@2059 := @2058 @149 +@2060 := @2057 @2059 +@2061 := @596 @2030 +@2062 := @595 @2061 +@2063 := LexLeanTarget.TargetSemantics.bindAll +@2064 := LexLeanTarget.TargetSyntax.Function.parameters +@2069 := @2062 (@2063 (@2064 @157) @149 @1686) +@2070 := @604 @2030 +@2071 := @2070 @151 +@2072 := @2069 @2071 +@2073 := @596 @2000 +@2074 := @595 @2073 +@2075 := LexLeanPreservation.Rust.fnFallible +@2078 := @2074 (@2075 @1931 @1846) +@2079 := @604 @2000 +@2080 := @2079 @151 +@2081 := @2078 @2080 +@2082 := LexLeanPreservation.RunConv +@2083 := #13 +@2087 := @2082 @2083 @1888 @163 @151 +@2089 := @2003 @149 @2008 +@2090 := Exists.{1} +@2091 := LexLeanPreservation.Rust.ROut +@2092 := @2090 @2091 +@2093 := And +@2094 := LexLeanPreservation.Rust.RealizesFn +@2098 := @2093 (@2094 @1846 @163 @4) +@2099 := LexLeanPreservation.Rust.RCI +@2100 := #15 +@2101 := @2099 @2100 +@2102 := LexLeanPreservation.Rust.fnIdent +@2103 := @2102 @2083 +@2110 := (hne : @2089) -> @2092 (fun (ro : @2091) => @2098 (@2101 @2103 @1931 @4)) +@2125 := {p : @32} -> + {c : @33} -> + {A : @34} -> + {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2037) -> + (hfn : @2053) -> (hwt : @2060) -> (hbind : @2072) -> (hF : @2081) -> (hA : @2087) -> @2110 +@2127 := LexLeanPreservation.Rust.compose @0 +@2128 := @2031 @0 +@2133 := (n : @35) -> @2128 @163 @157 @4 @149 +@2134 := @2046 @1703 +@2137 := @2039 (@2134 @149) @2052 +@2141 := @129 @1846 @163 @151 @2059 +@2142 := @2082 @0 +@2145 := @2142 @1888 @163 @151 +@2159 := {c : @33} -> + {A : @34} -> + {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2133) -> + (hfn : @2137) -> (hwt : @2141) -> (hbind : @2072) -> (hF : @2081) -> (hA : @2145) -> @2110 +@2160 := @2127 @1 +@2161 := @2128 @1 +@2165 := (n : @35) -> @2161 @157 @4 @149 +@2168 := @137 @163 @151 @2059 +@2169 := @2075 @1 +@2172 := @2074 (@2169 @1846) @2080 +@2173 := @2099 @1 +@2183 := (hbind : @2072) -> + (hF : @2172) -> + (hA : @2145) -> (hne : @2089) -> @2092 (fun (ro : @2091) => @2098 (@2173 @2103 @1931 @4)) +@2193 := {A : @34} -> + {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> {o : @2002} -> (hB : @2165) -> (hfn : @2137) -> (hwt : @2168) -> @2183 +@2194 := @2160 @2 +@2196 := @2161 @2 @4 +@2198 := (n : @35) -> @2196 @149 +@2199 := @143 @151 +@2200 := @2199 @2059 +@2209 := {f : @35} -> + {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> {o : @2002} -> (hB : @2198) -> (hfn : @2137) -> (hwt : @2200) -> @2183 +@2210 := @2194 @9 +@2212 := (n : @35) -> @2196 @9 +@2213 := @2134 @9 +@2214 := @2039 @2213 +@2215 := @2214 @2052 +@2216 := @2169 @9 +@2217 := @2074 @2216 +@2218 := @2217 @2080 +@2219 := @2142 @9 +@2221 := @2219 @163 @151 +@2223 := @2173 (@2102 @9) +@2231 := (hF : @2218) -> + (hA : @2221) -> (hne : @2089) -> @2092 (fun (ro : @2091) => @2098 (@2223 @1931 @4)) +@2240 := {fn : @1701} -> + {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> (hB : @2212) -> (hfn : @2215) -> (hwt : @2200) -> (hbind : @2072) -> @2231 +@2241 := @2210 @1719 +@2243 := @2214 (@2051 @1719) +@2244 := @2058 @1719 +@2245 := @2199 @2244 +@2247 := @2063 (@2064 @1719) +@2259 := {args : @147} -> + {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> (hwt : @2245) -> (hbind : @2062 (@2247 @149 @1686) @2071) -> @2231 +@2260 := @2241 @1667 +@2266 := @1933 (@1890 (@1848 (@1806 (@1766 (@1666 @95))))) +@2268 := @143 @2266 @2244 +@2269 := #12 +@2271 := @96 (@29 @2269) +@2277 := @2271 (@1933 (@1890 (@1848 (@1806 (@1766 @95))))) +@2281 := @2062 (@2247 @2277 @1686) @2071 +@2282 := #14 +@2284 := @96 (@29 @2282) +@2286 := @96 (@29 @2083) +@2292 := @2284 (@2286 (@2271 (@1933 (@1890 (@1848 @95))))) +@2294 := @2219 @2292 @151 +@2297 := @96 (@29 #17) +@2300 := @96 (@29 #16) +@2302 := @96 (@29 @2100) +@2323 := {env : @2030} -> + {F : @2000} -> + {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2268) -> + (hbind : @2281) -> + (hF : @2218) -> + (hA : @2294) -> + (hne : @2089) -> + @2092 (fun (ro : @2091) => @2098 (@2223 (@2297 (@2300 (@2302 (@2284 (@2286 (@2271 @95)))))) @4)) +@2324 := @2260 @1699 +@2330 := @1890 (@1848 (@1806 (@1766 (@1666 (@1664 @95))))) +@2332 := @143 @2330 @2244 +@2355 := @2062 + (@2247 @2266 @1686) + (@2070 + (@1687 + (@1674 @1632) + (@1687 + (@1676 @1765) + (@1687 + (@1678 @1805) + (@1687 (@1680 @1847) (@1687 (@1682 @1889) (@1687 (@1684 @1932) @1686))))))) +@2361 := @2286 (@2271 (@1933 (@1890 (@1848 (@1806 @95))))) +@2383 := {F : @2000} -> + {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2332) -> + (hbind : @2355) -> + (hF : @2218) -> + (hA : @2219 @2361 @151) -> + (hne : @2089) -> + @2092 (fun (ro : @2091) => @2098 (@2223 (@2300 (@2302 (@2284 (@2286 (@2271 (@1933 @95)))))) @4)) +@2384 := @2324 @1700 +@2385 := @1952 @2244 +@2408 := @2062 + (@2247 @2330 @1686) + (@2070 + (@1687 + (@1674 @1636) + (@1687 + (@1676 @1632) + (@1687 + (@1678 @1765) + (@1687 (@1680 @1805) (@1687 (@1682 @1847) (@1687 (@1684 @1889) @1686))))))) +@2410 := @2217 (@2079 @1700) +@2412 := @2219 @2277 @151 +@2413 := @2094 @1700 +@2435 := {o : @2002} -> + (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2385) -> + (hbind : @2408) -> + (hF : @2410) -> + (hA : @2412) -> + (hne : @2089) -> + @2092 + (fun (ro : @2091) => + @2093 (@2413 @163 @4) (@2223 (@2302 (@2284 (@2286 (@2271 (@1933 (@1890 @95)))))) @4)) +@2436 := @2384 @1977 +@2437 := @1959 @2244 +@2460 := @2062 + (@2247 @1951 @1686) + (@2070 + (@1687 + (@1674 @1640) + (@1687 + (@1676 @1636) + (@1687 + (@1678 @1632) + (@1687 (@1680 @1765) (@1687 (@1682 @1805) (@1687 (@1684 @1847) @1686))))))) +@2461 := @2219 @2266 +@2467 := @1971 @1931 @1888 @1846 @163 @157 @149 +@2468 := @2461 @2467 +@2474 := @1971 @2269 @1931 @1888 @1846 @163 @157 +@2497 := (hB : @2212) -> + (hfn : @2243) -> + (hwt : @2437) -> + (hbind : @2460) -> + (hF : @2410) -> + (hA : @2468) -> + (hne : @2003 @2474 @2008) -> + @2092 + (fun (ro : @2091) => + @2093 (@2413 (@1971 @2282 @2083 @2269 @1931 @1888 @1846) @4) (@2223 @2292 @4)) +@2498 := @2436 @1723 +@2499 := @1965 @2244 +@2522 := @2062 + (@2247 @1958 @1686) + (@2070 + (@1687 + (@1674 @1644) + (@1687 + (@1676 @1640) + (@1687 + (@1678 @1636) + (@1687 (@1680 @1632) (@1687 (@1682 @1765) (@1687 (@1684 @1805) @1686))))))) +@2523 := @2219 @2330 +@2529 := @1971 @1888 @1846 @163 @157 @149 @151 +@2552 := (hfn : @2243) -> + (hwt : @2499) -> + (hbind : @2522) -> + (hF : @2410) -> + (hA : @2523 @2529) -> + (hne : @2003 @2467 @2008) -> + @2092 + (fun (ro : @2091) => + @2093 (@2413 (@1971 @2083 @2269 @1931 @1888 @1846 @163) @4) (@2223 @2361 @4)) +@2555 := @2498 (@704 @2038 @2213) +@2556 := @1969 @2244 +@2579 := @2062 + (@2247 @1964 @1686) + (@2070 + (@1687 + (@1674 @1648) + (@1687 + (@1676 @1644) + (@1687 + (@1678 @1640) + (@1687 (@1680 @1636) (@1687 (@1682 @1632) (@1687 (@1684 @1765) @1686))))))) +@2580 := @2219 @1951 +@2586 := @1971 @1846 @163 @157 @149 @151 @153 +@2602 := (hwt : @2556) -> + (hbind : @2579) -> + (hF : @2410) -> + (hA : @2580 @2586) -> + (hne : @2003 @2529 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2474 @4) (@2223 @2277 @4)) +@2603 := @2555 @1968 +@2605 := @2247 @1667 @1686 +@2608 := @2062 @2605 (@2070 @1699) +@2609 := @2219 @1958 +@2615 := @1971 @163 @157 @149 @151 @153 @36 +@2630 := (hbind : @2608) -> + (hF : @2410) -> + (hA : @2609 @2615) -> + (hne : @2003 @2586 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2467 @4) (@2223 @2266 @4)) +@2633 := @2603 (@704 @2061 @2605) +@2634 := @2219 @1964 +@2640 := @1971 @157 @149 @151 @153 @36 @38 +@2654 := (hF : @2410) -> + (hA : @2634 @2640) -> + (hne : @2003 @2615 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2529 @4) (@2223 @2330 @4)) +@2657 := @2633 (@704 @2073 @2216) +@2671 := (hA : @2219 @1667 @1977) -> + (hne : @2003 @2640 @2008) -> @2092 (fun (ro : @2091) => @2093 (@2413 @2586 @4) (@2223 @1951 @4)) +@2672 := @2657 @1999 +@2683 := (hne : @2003 @1977 @2008) -> + @2092 (fun (ro : @2091) => @2093 (@2413 @2615 @4) (@2223 @1958 @4)) +@2684 := @2672 @2025 +@2690 := @2093 (@2413 @2640 @4) (@2223 @1964 @4) +@2692 := @2092 (fun (ro : @2091) => @2690) +@2694 := @2092 (fun (__e_ro : @2091) => @2690) +@2703 := LexLeanPreservation.Rust.RepresentableL + (@1664 (@1662 (@1660 (@1658 (@1656 (@96 @42 @95)))))) +@2704 := (__e_hrep : @2703) -> @2694 +@2705 := fun (__e_hrep : @2703) => @2684 +@2706 := (infection : @35) -> @2704 +@2707 := fun (infection : @35) => @2705 +@2708 := (systolic : @35) -> @2706 +@2709 := fun (systolic : @35) => @2707 +@2710 := (whiteCells : @35) -> @2708 +@2711 := fun (whiteCells : @35) => @2709 +@2712 := (respiratoryRate : @35) -> @2710 +@2713 := fun (respiratoryRate : @35) => @2711 +@2714 := (heartRate : @35) -> @2712 +@2715 := fun (heartRate : @35) => @2713 +@2716 := (temperature : @35) -> @2714 +@2717 := fun (temperature : @35) => @2715 +\end{coremodule} +\end{lexlean} diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R6/Compose/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R6/Compose/RustStd.lean deleted file mode 100644 index a0ed9e85c..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R6/Compose/RustStd.lean +++ /dev/null @@ -1,28 +0,0 @@ -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6 -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Reasoning.Screening.Screen.Step)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.__enc_0 __v) (.adt 0) - | Reasoning.Screening.Screen.Step.Propose __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - -theorem __wt_2 : ∀ (__s : (Reasoning.Screening.Screen.Node)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.__enc_2 __s) (.adt 2) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat _root_.LexLeanPreservation.Rust.wt_nat) (__s).state) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList __wt_0) (__s).trace) _root_.LexLeanPreservation.Rust.wtl_nil)) - -theorem __wt_3 : ∀ (__s : (Reasoning.Screening.Screen.Ledger)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.__enc_3 __s) (.adt 3) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).iterations) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).attempts) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).firings) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).expansions) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).verifications) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat (__s).frontier) _root_.LexLeanPreservation.Rust.wtl_nil)))))) - -theorem __wt_1 : ∀ (__s : (Reasoning.Screening.Screen.Search)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.__enc_1 __s) (.adt 1) := - fun __s => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encList __wt_2) (__s).frontier) (_root_.LexLeanPreservation.Rust.wtl_cons ((_root_.LexLeanPreservation.Rust.wt_encOption (_root_.LexLeanPreservation.Rust.wt_encPair _root_.LexLeanPreservation.Rust.wt_nat __wt_2)) (__s).found) (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_bool (__s).truncated) (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_3 (__s).ledger) _root_.LexLeanPreservation.Rust.wtl_nil)))) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (w : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat w)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.denote w) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat w)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat w) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.root w) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R6/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R6/Compose/RustStd.lex.tex new file mode 100644 index 000000000..61a7141db --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R6/Compose/RustStd.lex.tex @@ -0,0 +1,1218 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6, + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_0 : @16 := @367 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_2 : @375 := @849 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_3 : @857 := @1316 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_3], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_1 : @1324 := @1844 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.root : @2457 := @2458 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.program +@1 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.krate +@2 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.flags +@3 := Reasoning.Screening.Screen.Step +@4 := #0 +@5 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.__enc_0 +@6 := @5 @4 +@7 := LexLeanPreservation.Rust.WT +@8 := LexLeanTarget.TargetSyntax.Ty.adt +@9 := 0 +@10 := @8 @9 +@11 := @7 @0 +@12 := @11 @1 +@13 := @12 @2 +@14 := @13 @6 +@15 := @14 @10 +@16 := (__v : @3) -> @15 +@17 := fun (__v : @3) => @15 +@18 := LexLeanTarget.TargetSyntax.Value.nat +@19 := @18 @4 +@20 := LexLeanTarget.TargetSyntax.Ty.nat +@21 := LexLeanTarget.TargetSyntax.Program +@22 := LexLeanPreservation.Rust.RCrate +@23 := LexLeanPreservation.Rust.Flags +@24 := Nat +@25 := #3 +@26 := @7 @25 +@27 := #2 +@28 := @26 @27 +@29 := #1 +@30 := @28 @29 +@36 := {p : @21} -> {c : @22} -> {A : @23} -> (n : @24) -> @30 @19 @20 +@38 := LexLeanPreservation.Rust.wt_nat @0 +@40 := @11 @27 @29 +@45 := {c : @22} -> {A : @23} -> (n : @24) -> @40 @19 @20 +@46 := @38 @1 +@47 := @12 @29 +@51 := {A : @23} -> (n : @24) -> @47 @19 @20 +@52 := @46 @2 +@53 := @13 @19 +@54 := @53 @20 +@55 := (n : @24) -> @54 +@56 := @52 @4 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := LexLeanTarget.TargetSyntax.Ty +@59 := List.nil.{0} +@60 := List.cons.{0} +@61 := @59 @57 +@62 := @60 @57 +@64 := @62 @19 @61 +@65 := @59 @58 +@66 := @60 @58 +@67 := @66 @20 +@68 := @67 @65 +@69 := LexLeanPreservation.Rust.WTL +@77 := {p : @21} -> {c : @22} -> {A : @23} -> @69 @27 @29 @4 @61 @65 +@79 := LexLeanPreservation.Rust.wtl_nil @0 +@80 := @69 @0 +@86 := {c : @22} -> {A : @23} -> @80 @29 @4 @61 @65 +@87 := @79 @1 +@88 := @80 @1 +@92 := {A : @23} -> @88 @4 @61 @65 +@93 := @87 @2 +@94 := @88 @2 +@95 := @94 @61 +@96 := @95 @65 +@97 := List.{0} +@98 := @97 @57 +@99 := @97 @58 +@100 := #6 +@101 := @7 @100 +@102 := #5 +@103 := @101 @102 +@104 := #4 +@105 := @103 @104 +@107 := @105 @25 @27 +@108 := #7 +@113 := @69 @108 @100 @102 @27 @29 +@114 := #8 +@117 := @69 @114 @108 @100 +@119 := @62 @102 @25 +@120 := @117 @119 +@122 := @66 @104 @27 +@132 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {v : @57} -> {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @107) -> (hs : @113) -> @120 @122 +@134 := LexLeanPreservation.Rust.wtl_cons @0 +@136 := @11 @102 @104 +@138 := @136 @25 @27 +@142 := @80 @100 @102 @27 @29 +@154 := {c : @22} -> + {A : @23} -> + {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @138) -> (hs : @142) -> @80 @108 @100 @119 @122 +@155 := @134 @1 +@156 := @12 @104 +@158 := @156 @25 @27 +@161 := @88 @102 @27 @29 +@171 := {A : @23} -> + {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @158) -> (hs : @161) -> @88 @100 @119 @122 +@172 := @155 @2 +@174 := @13 @25 @27 +@176 := @94 @27 @29 +@184 := {v : @57} -> + {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @174) -> (hs : @176) -> @94 @119 @122 +@185 := @172 @19 +@186 := @18 @25 +@187 := @13 @186 +@188 := @187 @27 +@189 := @18 @102 +@190 := @62 @189 +@192 := @94 (@190 @25) +@198 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @188) -> (hs : @176) -> @192 @122 +@199 := @185 @20 +@200 := @18 @27 +@202 := @13 @200 @20 +@203 := @18 @104 +@204 := @62 @203 +@206 := @94 (@204 @25) +@207 := @67 @27 +@212 := {vs : @98} -> {ts : @99} -> (h : @202) -> (hs : @176) -> @206 @207 +@213 := @199 @61 +@214 := @18 @29 +@216 := @13 @214 @20 +@217 := @95 @29 +@219 := @62 @186 @61 +@220 := @94 @219 +@224 := {ts : @99} -> (h : @216) -> (hs : @217) -> @220 @207 +@225 := @213 @65 +@227 := @62 @200 @61 +@228 := @94 @227 +@231 := (h : @54) -> (hs : @96) -> @228 @68 +@232 := @225 @56 +@234 := @62 @214 @61 +@235 := @94 @234 +@236 := @235 @68 +@237 := (hs : @96) -> @236 +@238 := @232 @93 +@240 := @94 @64 @68 +@241 := Eq.{1} +@242 := Option.{0} +@243 := @242 @99 +@244 := @241 @243 +@245 := LexLeanPreservation.Rust.adtFields +@249 := @244 (@245 @100 @25 @27) +@250 := Option.some.{0} +@251 := @250 @99 +@252 := @251 @4 +@253 := @249 @252 +@256 := @7 @114 @108 @100 +@257 := LexLeanTarget.TargetSyntax.Value.adt +@259 := @257 @104 @25 +@260 := @256 @259 +@261 := @8 @102 +@271 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {i : @24} -> {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @253) -> (hf : @113) -> @260 @261 +@273 := LexLeanPreservation.Rust.wt_adt @0 +@274 := @245 @0 +@278 := @244 (@274 @25 @27) @252 +@290 := {c : @22} -> + {A : @23} -> + {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @142) -> @11 @108 @100 @259 @261 +@291 := @273 @1 +@301 := {A : @23} -> + {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @161) -> @12 @100 @259 @261 +@302 := @291 @2 +@303 := @13 @259 +@310 := {i : @24} -> + {k : @24} -> {fs : @98} -> {tys : @99} -> (h : @278) -> (hf : @176) -> @303 @261 +@311 := @302 @9 +@312 := @274 @9 +@321 := {k : @24} -> + {fs : @98} -> {tys : @99} -> (h : @244 (@312 @27) @252) -> (hf : @176) -> @303 @10 +@322 := @311 @9 +@323 := @312 @9 +@324 := @244 @323 +@325 := @324 @252 +@326 := @257 @9 +@328 := @13 (@326 @25) +@333 := {fs : @98} -> {tys : @99} -> (h : @325) -> (hf : @176) -> @328 @10 +@334 := @322 @64 +@341 := {tys : @99} -> (h : @325) -> (hf : @228 @29) -> @13 (@326 @219) @10 +@342 := @334 @68 +@349 := (h : @324 (@251 @68)) -> (hf : @236) -> @13 (@326 @227) @10 +@350 := Eq.refl.{1} +@351 := @350 @243 +@353 := @342 (@351 @323) +@357 := (hf : @240) -> @13 (@326 @234) @10 +@358 := @353 @238 +@361 := @13 (@326 @64) @10 +@362 := fun (__x0 : @24) => @358 +@367 := fun (__v : @3) => Reasoning.Screening.Screen.Step.casesOn.{0} @17 @4 @362 +@368 := Reasoning.Screening.Screen.Node +@369 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.__enc_2 +@370 := @369 @4 +@371 := 2 +@372 := @8 @371 +@373 := @13 @370 +@374 := @373 @372 +@375 := (__s : @368) -> @374 +@376 := Reasoning.Screening.Screen.Node.state +@377 := @376 @4 +@378 := Reasoning.Screening.Screen.Node.trace +@379 := @378 @4 +@380 := LexLeanPreservation.encPair +@381 := @380 @24 +@382 := @381 @24 +@383 := @382 @18 +@384 := @383 @18 +@385 := @384 @377 +@386 := LexLeanTarget.TargetSyntax.Ty.pair +@387 := @386 @20 +@388 := @387 @20 +@389 := fun (__x : @24) => @56 +@390 := Sort 1 +@391 := (a._@._internal._hyg.#0 : @29) -> @57 +@392 := #9 +@395 := @7 @392 @114 @108 +@396 := @104 @4 +@399 := (x : @102) -> @395 @396 @27 +@400 := #10 +@406 := (x : @102) -> @7 @400 @392 @114 @396 @27 +@407 := Prod.{0, 0} +@409 := @407 @108 @100 +@410 := #11 +@413 := @7 @410 @400 @392 +@418 := @380 @114 @108 @100 @102 @4 +@419 := @413 @418 +@421 := @386 @104 @25 +@434 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {α : @390} -> + {β : @390} -> + {ea : @391} -> + {eb : @391} -> {s : @58} -> {t : @58} -> (ha : @399) -> (hb : @406) -> (x : @409) -> @419 @421 +@436 := LexLeanPreservation.Rust.wt_encPair @0 +@461 := {c : @22} -> + {A : @23} -> + {α : @390} -> + {β : @390} -> + {ea : @391} -> + {eb : @391} -> + {s : @58} -> + {t : @58} -> + (ha : (x : @102) -> @11 @114 @108 @396 @27) -> + (hb : (x : @102) -> @11 @392 @114 @396 @27) -> (x : @409) -> @11 @400 @392 @418 @421 +@462 := @436 @1 +@483 := {A : @23} -> + {α : @390} -> + {β : @390} -> + {ea : @391} -> + {eb : @391} -> + {s : @58} -> + {t : @58} -> + (ha : (x : @102) -> @12 @108 @396 @27) -> + (hb : (x : @102) -> @12 @114 @396 @27) -> (x : @409) -> @12 @392 @418 @421 +@484 := @462 @2 +@486 := @13 @396 @27 +@487 := (x : @102) -> @486 +@498 := {α : @390} -> + {β : @390} -> + {ea : @391} -> + {eb : @391} -> {s : @58} -> {t : @58} -> (ha : @487) -> (hb : @487) -> (x : @409) -> @13 @418 @421 +@499 := @484 @24 +@500 := (a._@._internal._hyg.#0 : @24) -> @57 +@501 := (x : @24) -> @486 +@502 := @407 @24 +@517 := {β : @390} -> + {ea : @500} -> + {eb : @391} -> + {s : @58} -> + {t : @58} -> (ha : @501) -> (hb : @487) -> (x : @502 @100) -> @13 (@381 @108 @100 @102 @4) @421 +@518 := @499 @24 +@519 := @502 @24 +@531 := {ea : @500} -> + {eb : @500} -> + {s : @58} -> {t : @58} -> (ha : @501) -> (hb : @501) -> (x : @519) -> @13 (@382 @100 @102 @4) @421 +@532 := @518 @18 +@534 := (x : @24) -> @53 @27 +@544 := {eb : @500} -> + {s : @58} -> {t : @58} -> (ha : @534) -> (hb : @501) -> (x : @519) -> @13 (@383 @102 @4) @421 +@545 := @532 @18 +@547 := @13 (@384 @4) +@553 := {s : @58} -> {t : @58} -> (ha : @534) -> (hb : @534) -> (x : @519) -> @547 @421 +@554 := @545 @20 +@555 := (x : @24) -> @54 +@556 := @387 @25 +@561 := {t : @58} -> (ha : @555) -> (hb : @534) -> (x : @519) -> @547 @556 +@562 := @554 @20 +@566 := (ha : @555) -> (hb : @555) -> (x : @519) -> @547 @388 +@569 := @562 @389 @389 @377 +@571 := @13 @385 @388 +@572 := LexLeanPreservation.encList +@573 := @572 @3 +@574 := @573 @5 +@575 := @574 @379 +@576 := LexLeanTarget.TargetSyntax.Ty.list +@577 := @576 @10 +@580 := fun (__x : @3) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_0 @4 +@581 := (a._@._internal._hyg.#0 : @4) -> @57 +@582 := @27 @4 +@585 := (x : @27) -> @105 @582 @29 +@586 := @97 @25 +@589 := @7 @108 @100 @102 +@592 := @572 @104 @25 @4 +@593 := @589 @592 +@594 := @576 @27 +@603 := {p : @21} -> + {c : @22} -> + {A : @23} -> {α : @390} -> {e : @581} -> {t : @58} -> (h : @585) -> (xs : @586) -> @593 @594 +@605 := LexLeanPreservation.Rust.wt_encList @0 +@608 := (x : @27) -> @136 @582 @29 +@610 := @11 @100 @102 +@619 := {c : @22} -> + {A : @23} -> {α : @390} -> {e : @581} -> {t : @58} -> (h : @608) -> (xs : @586) -> @610 @592 @594 +@620 := @605 @1 +@623 := (x : @27) -> @156 @582 @29 +@624 := @12 @102 +@632 := {A : @23} -> + {α : @390} -> {e : @581} -> {t : @58} -> (h : @623) -> (xs : @586) -> @624 @592 @594 +@633 := @620 @2 +@635 := @13 @582 @29 +@636 := (x : @27) -> @635 +@643 := {α : @390} -> {e : @581} -> {t : @58} -> (h : @636) -> (xs : @586) -> @13 @592 @594 +@644 := @633 @3 +@645 := (a._@._internal._hyg.#0 : @3) -> @57 +@646 := (x : @3) -> @635 +@647 := @97 @3 +@655 := {e : @645} -> {t : @58} -> (h : @646) -> (xs : @647) -> @13 (@573 @25 @4) @594 +@656 := @644 @5 +@658 := (x : @3) -> @14 @29 +@660 := @13 (@574 @4) +@664 := {t : @58} -> (h : @658) -> (xs : @647) -> @660 @594 +@665 := @656 @10 +@669 := (h : (x : @3) -> @15) -> (xs : @647) -> @660 @577 +@671 := @665 @580 @379 +@673 := @13 @575 @577 +@675 := @62 @575 @61 +@677 := @62 @385 @675 +@678 := @66 @577 +@679 := @678 @65 +@680 := @66 @388 +@681 := @680 @679 +@682 := @172 @575 +@684 := @574 (@378 @25) +@697 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @684 @27) -> (hs : @176) -> @94 (@62 (@574 (@378 @102)) @25) @122 +@698 := @682 @577 +@700 := @574 (@378 @27) +@702 := @13 @700 @577 +@707 := @94 (@62 (@574 (@378 @104)) @25) +@708 := @678 @27 +@713 := {vs : @98} -> {ts : @99} -> (h : @702) -> (hs : @176) -> @707 @708 +@714 := @698 @61 +@716 := @574 (@378 @29) +@718 := @13 @716 @577 +@720 := @62 @684 @61 +@725 := {ts : @99} -> (h : @718) -> (hs : @217) -> @94 @720 @708 +@726 := @714 @65 +@728 := @62 @700 @61 +@729 := @94 @728 +@732 := (h : @673) -> (hs : @96) -> @729 @679 +@733 := @726 @671 +@735 := @62 @716 @61 +@737 := @94 @735 @679 +@738 := (hs : @96) -> @737 +@739 := @733 @93 +@741 := @94 @675 @679 +@742 := @172 @385 +@744 := @384 (@376 @25) +@757 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @744 @27) -> (hs : @176) -> @94 (@62 (@384 (@376 @102)) @25) @122 +@758 := @742 @388 +@760 := @384 (@376 @27) +@762 := @13 @760 @388 +@767 := @94 (@62 (@384 (@376 @104)) @25) +@768 := @680 @27 +@773 := {vs : @98} -> {ts : @99} -> (h : @762) -> (hs : @176) -> @767 @768 +@774 := @758 @675 +@776 := @384 (@376 @29) +@778 := @13 @776 @388 +@779 := @729 @29 +@781 := @62 @744 @720 +@786 := {ts : @99} -> (h : @778) -> (hs : @779) -> @94 @781 @768 +@787 := @774 @679 +@789 := @62 @760 @728 +@790 := @94 @789 +@793 := (h : @571) -> (hs : @737) -> @790 @681 +@794 := @787 @569 +@796 := @62 @776 @735 +@798 := @94 @796 @681 +@799 := (hs : @741) -> @798 +@800 := @794 @739 +@802 := @94 @677 @681 +@803 := @302 @371 +@804 := @274 @371 +@813 := {k : @24} -> + {fs : @98} -> {tys : @99} -> (h : @244 (@804 @27) @252) -> (hf : @176) -> @303 @372 +@814 := @803 @9 +@815 := @804 @9 +@816 := @244 @815 +@817 := @816 @252 +@822 := {fs : @98} -> {tys : @99} -> (h : @817) -> (hf : @176) -> @328 @372 +@823 := @814 @677 +@830 := {tys : @99} -> (h : @817) -> (hf : @790 @29) -> @13 (@326 @781) @372 +@831 := @823 @681 +@838 := (h : @816 (@251 @681)) -> (hf : @798) -> @13 (@326 @789) @372 +@840 := @831 (@351 @815) +@844 := (hf : @802) -> @13 (@326 @796) @372 +@845 := @840 @800 +@848 := @13 (@326 @677) @372 +@849 := fun (__s : @368) => @845 +@850 := Reasoning.Screening.Screen.Ledger +@851 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.__enc_3 +@852 := @851 @4 +@853 := 3 +@854 := @8 @853 +@857 := (__s : @850) -> @13 @852 @854 +@858 := Reasoning.Screening.Screen.Ledger.iterations +@859 := @858 @4 +@860 := Reasoning.Screening.Screen.Ledger.attempts +@861 := @860 @4 +@862 := Reasoning.Screening.Screen.Ledger.firings +@863 := @862 @4 +@864 := Reasoning.Screening.Screen.Ledger.expansions +@865 := @864 @4 +@866 := Reasoning.Screening.Screen.Ledger.verifications +@867 := @866 @4 +@868 := Reasoning.Screening.Screen.Ledger.frontier +@869 := @868 @4 +@870 := @18 @859 +@871 := @52 @859 +@873 := @13 @870 @20 +@874 := @18 @861 +@875 := @52 @861 +@877 := @13 @874 @20 +@878 := @18 @863 +@879 := @52 @863 +@881 := @13 @878 @20 +@882 := @18 @865 +@883 := @52 @865 +@885 := @13 @882 @20 +@886 := @18 @867 +@887 := @52 @867 +@889 := @13 @886 @20 +@890 := @18 @869 +@891 := @52 @869 +@893 := @13 @890 @20 +@895 := @62 @890 @61 +@897 := @62 @886 @895 +@899 := @62 @882 @897 +@901 := @62 @878 @899 +@903 := @62 @874 @901 +@905 := @62 @870 @903 +@906 := @67 @68 +@907 := @67 @906 +@908 := @67 @907 +@909 := @67 @908 +@910 := @67 @909 +@911 := @172 @890 +@913 := @18 (@868 @25) +@926 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @913 @27) -> (hs : @176) -> @94 (@62 (@18 (@868 @102)) @25) @122 +@927 := @911 @20 +@929 := @18 (@868 @27) +@941 := {vs : @98} -> + {ts : @99} -> (h : @13 @929 @20) -> (hs : @176) -> @94 (@62 (@18 (@868 @104)) @25) @207 +@942 := @927 @61 +@944 := @18 (@868 @29) +@946 := @13 @944 @20 +@948 := @62 @913 @61 +@953 := {ts : @99} -> (h : @946) -> (hs : @217) -> @94 @948 @207 +@954 := @942 @65 +@956 := @62 @929 @61 +@957 := @94 @956 +@960 := (h : @893) -> (hs : @96) -> @957 @68 +@961 := @954 @891 +@963 := @62 @944 @61 +@965 := @94 @963 @68 +@966 := (hs : @96) -> @965 +@967 := @961 @93 +@969 := @94 @895 @68 +@970 := @172 @886 +@972 := @18 (@866 @25) +@985 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @972 @27) -> (hs : @176) -> @94 (@62 (@18 (@866 @102)) @25) @122 +@986 := @970 @20 +@988 := @18 (@866 @27) +@1000 := {vs : @98} -> + {ts : @99} -> (h : @13 @988 @20) -> (hs : @176) -> @94 (@62 (@18 (@866 @104)) @25) @207 +@1001 := @986 @895 +@1003 := @18 (@866 @29) +@1005 := @13 @1003 @20 +@1006 := @957 @29 +@1008 := @62 @972 @948 +@1013 := {ts : @99} -> (h : @1005) -> (hs : @1006) -> @94 @1008 @207 +@1014 := @1001 @68 +@1016 := @62 @988 @956 +@1017 := @94 @1016 +@1020 := (h : @889) -> (hs : @965) -> @1017 @906 +@1021 := @1014 @887 +@1023 := @62 @1003 @963 +@1025 := @94 @1023 @906 +@1026 := (hs : @969) -> @1025 +@1027 := @1021 @967 +@1029 := @94 @897 @906 +@1030 := @172 @882 +@1032 := @18 (@864 @25) +@1045 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @1032 @27) -> (hs : @176) -> @94 (@62 (@18 (@864 @102)) @25) @122 +@1046 := @1030 @20 +@1048 := @18 (@864 @27) +@1060 := {vs : @98} -> + {ts : @99} -> (h : @13 @1048 @20) -> (hs : @176) -> @94 (@62 (@18 (@864 @104)) @25) @207 +@1061 := @1046 @897 +@1063 := @18 (@864 @29) +@1065 := @13 @1063 @20 +@1066 := @1017 @29 +@1068 := @62 @1032 @1008 +@1073 := {ts : @99} -> (h : @1065) -> (hs : @1066) -> @94 @1068 @207 +@1074 := @1061 @906 +@1076 := @62 @1048 @1016 +@1077 := @94 @1076 +@1080 := (h : @885) -> (hs : @1025) -> @1077 @907 +@1081 := @1074 @883 +@1083 := @62 @1063 @1023 +@1085 := @94 @1083 @907 +@1086 := (hs : @1029) -> @1085 +@1087 := @1081 @1027 +@1089 := @94 @899 @907 +@1090 := @172 @878 +@1092 := @18 (@862 @25) +@1105 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @1092 @27) -> (hs : @176) -> @94 (@62 (@18 (@862 @102)) @25) @122 +@1106 := @1090 @20 +@1108 := @18 (@862 @27) +@1120 := {vs : @98} -> + {ts : @99} -> (h : @13 @1108 @20) -> (hs : @176) -> @94 (@62 (@18 (@862 @104)) @25) @207 +@1121 := @1106 @899 +@1123 := @18 (@862 @29) +@1125 := @13 @1123 @20 +@1126 := @1077 @29 +@1128 := @62 @1092 @1068 +@1133 := {ts : @99} -> (h : @1125) -> (hs : @1126) -> @94 @1128 @207 +@1134 := @1121 @907 +@1136 := @62 @1108 @1076 +@1137 := @94 @1136 +@1140 := (h : @881) -> (hs : @1085) -> @1137 @908 +@1141 := @1134 @879 +@1143 := @62 @1123 @1083 +@1145 := @94 @1143 @908 +@1146 := (hs : @1089) -> @1145 +@1147 := @1141 @1087 +@1149 := @94 @901 @908 +@1150 := @172 @874 +@1152 := @18 (@860 @25) +@1165 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @1152 @27) -> (hs : @176) -> @94 (@62 (@18 (@860 @102)) @25) @122 +@1166 := @1150 @20 +@1168 := @18 (@860 @27) +@1180 := {vs : @98} -> + {ts : @99} -> (h : @13 @1168 @20) -> (hs : @176) -> @94 (@62 (@18 (@860 @104)) @25) @207 +@1181 := @1166 @901 +@1183 := @18 (@860 @29) +@1185 := @13 @1183 @20 +@1186 := @1137 @29 +@1188 := @62 @1152 @1128 +@1193 := {ts : @99} -> (h : @1185) -> (hs : @1186) -> @94 @1188 @207 +@1194 := @1181 @908 +@1196 := @62 @1168 @1136 +@1197 := @94 @1196 +@1200 := (h : @877) -> (hs : @1145) -> @1197 @909 +@1201 := @1194 @875 +@1203 := @62 @1183 @1143 +@1205 := @94 @1203 @909 +@1206 := (hs : @1149) -> @1205 +@1207 := @1201 @1147 +@1209 := @94 @903 @909 +@1210 := @172 @870 +@1212 := @18 (@858 @25) +@1225 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @1212 @27) -> (hs : @176) -> @94 (@62 (@18 (@858 @102)) @25) @122 +@1226 := @1210 @20 +@1228 := @18 (@858 @27) +@1240 := {vs : @98} -> + {ts : @99} -> (h : @13 @1228 @20) -> (hs : @176) -> @94 (@62 (@18 (@858 @104)) @25) @207 +@1241 := @1226 @903 +@1243 := @18 (@858 @29) +@1245 := @13 @1243 @20 +@1246 := @1197 @29 +@1248 := @62 @1212 @1188 +@1253 := {ts : @99} -> (h : @1245) -> (hs : @1246) -> @94 @1248 @207 +@1254 := @1241 @909 +@1256 := @62 @1228 @1196 +@1257 := @94 @1256 +@1260 := (h : @873) -> (hs : @1205) -> @1257 @910 +@1261 := @1254 @871 +@1263 := @62 @1243 @1203 +@1265 := @94 @1263 @910 +@1266 := (hs : @1209) -> @1265 +@1267 := @1261 @1207 +@1269 := @94 @905 @910 +@1270 := @302 @853 +@1271 := @274 @853 +@1280 := {k : @24} -> + {fs : @98} -> {tys : @99} -> (h : @244 (@1271 @27) @252) -> (hf : @176) -> @303 @854 +@1281 := @1270 @9 +@1282 := @1271 @9 +@1283 := @244 @1282 +@1284 := @1283 @252 +@1289 := {fs : @98} -> {tys : @99} -> (h : @1284) -> (hf : @176) -> @328 @854 +@1290 := @1281 @905 +@1297 := {tys : @99} -> (h : @1284) -> (hf : @1257 @29) -> @13 (@326 @1248) @854 +@1298 := @1290 @910 +@1305 := (h : @1283 (@251 @910)) -> (hf : @1265) -> @13 (@326 @1256) @854 +@1307 := @1298 (@351 @1282) +@1311 := (hf : @1269) -> @13 (@326 @1263) @854 +@1312 := @1307 @1267 +@1315 := @13 (@326 @905) @854 +@1316 := fun (__s : @850) => @1312 +@1317 := Reasoning.Screening.Screen.Search +@1319 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.__enc_1 @4 +@1320 := 1 +@1321 := @8 @1320 +@1324 := (__s : @1317) -> @13 @1319 @1321 +@1325 := Reasoning.Screening.Screen.Search.frontier +@1326 := @1325 @4 +@1327 := Reasoning.Screening.Screen.Search.found +@1328 := @1327 @4 +@1329 := Reasoning.Screening.Screen.Search.truncated +@1330 := @1329 @4 +@1331 := Reasoning.Screening.Screen.Search.ledger +@1332 := @1331 @4 +@1333 := @572 @368 +@1334 := @1333 @369 +@1335 := @1334 @1326 +@1336 := @576 @372 +@1339 := fun (__x : @368) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_2 @4 +@1340 := @633 @368 +@1341 := (a._@._internal._hyg.#0 : @368) -> @57 +@1342 := (x : @368) -> @635 +@1343 := @97 @368 +@1351 := {e : @1341} -> {t : @58} -> (h : @1342) -> (xs : @1343) -> @13 (@1333 @25 @4) @594 +@1352 := @1340 @369 +@1354 := (x : @368) -> @373 @29 +@1356 := @13 (@1334 @4) +@1360 := {t : @58} -> (h : @1354) -> (xs : @1343) -> @1356 @594 +@1361 := @1352 @372 +@1362 := (x : @368) -> @374 +@1365 := (h : @1362) -> (xs : @1343) -> @1356 @1336 +@1367 := @1361 @1339 @1326 +@1369 := @13 @1335 @1336 +@1370 := @502 @368 +@1371 := @381 @368 +@1372 := @1371 @18 +@1373 := @1372 @369 +@1374 := LexLeanPreservation.encOption +@1375 := @1374 @1370 +@1376 := @1375 @1373 +@1377 := @1376 @1328 +@1378 := @387 @372 +@1379 := LexLeanTarget.TargetSyntax.Ty.option +@1380 := @1379 @1378 +@1381 := @499 @368 +@1382 := (x : @368) -> @486 +@1394 := {ea : @500} -> + {eb : @1341} -> + {s : @58} -> + {t : @58} -> (ha : @501) -> (hb : @1382) -> (x : @1370) -> @13 (@1371 @100 @102 @4) @421 +@1395 := @1381 @18 +@1405 := {eb : @1341} -> + {s : @58} -> {t : @58} -> (ha : @534) -> (hb : @1382) -> (x : @1370) -> @13 (@1372 @102 @4) @421 +@1406 := @1395 @369 +@1408 := (x : @368) -> @373 @27 +@1410 := @13 (@1373 @4) +@1416 := {s : @58} -> {t : @58} -> (ha : @534) -> (hb : @1408) -> (x : @1370) -> @1410 @421 +@1417 := @1406 @20 +@1422 := {t : @58} -> (ha : @555) -> (hb : @1408) -> (x : @1370) -> @1410 @556 +@1423 := @1417 @372 +@1425 := (x : @1370) -> @1410 @1378 +@1427 := (ha : @555) -> (hb : @1362) -> @1425 +@1431 := fun (__x : @1370) => @1423 @389 @1339 @4 +@1432 := @242 @25 +@1435 := @1374 @104 @25 @4 +@1436 := @589 @1435 +@1437 := @1379 @27 +@1446 := {p : @21} -> + {c : @22} -> + {A : @23} -> {α : @390} -> {e : @581} -> {t : @58} -> (h : @585) -> (o : @1432) -> @1436 @1437 +@1448 := LexLeanPreservation.Rust.wt_encOption @0 +@1457 := {c : @22} -> + {A : @23} -> + {α : @390} -> {e : @581} -> {t : @58} -> (h : @608) -> (o : @1432) -> @610 @1435 @1437 +@1458 := @1448 @1 +@1466 := {A : @23} -> + {α : @390} -> {e : @581} -> {t : @58} -> (h : @623) -> (o : @1432) -> @624 @1435 @1437 +@1467 := @1458 @2 +@1474 := {α : @390} -> {e : @581} -> {t : @58} -> (h : @636) -> (o : @1432) -> @13 @1435 @1437 +@1475 := @1467 @1370 +@1476 := (a._@._internal._hyg.#0 : @1370) -> @57 +@1477 := (x : @1370) -> @635 +@1478 := @242 @1370 +@1486 := {e : @1476} -> {t : @58} -> (h : @1477) -> (o : @1478) -> @13 (@1375 @25 @4) @1437 +@1487 := @1475 @1373 +@1489 := (x : @1370) -> @1410 @29 +@1491 := @13 (@1376 @4) +@1495 := {t : @58} -> (h : @1489) -> (o : @1478) -> @1491 @1437 +@1496 := @1487 @1378 +@1499 := (h : @1425) -> (o : @1478) -> @1491 @1380 +@1501 := @1496 @1431 @1328 +@1503 := @13 @1377 @1380 +@1504 := LexLeanTarget.TargetSyntax.Value.bool +@1505 := @1504 @1330 +@1506 := LexLeanTarget.TargetSyntax.Ty.bool +@1507 := Bool +@1508 := @1504 @4 +@1514 := {p : @21} -> {c : @22} -> {A : @23} -> (b : @1507) -> @30 @1508 @1506 +@1516 := LexLeanPreservation.Rust.wt_bool @0 +@1521 := {c : @22} -> {A : @23} -> (b : @1507) -> @40 @1508 @1506 +@1522 := @1516 @1 +@1526 := {A : @23} -> (b : @1507) -> @47 @1508 @1506 +@1527 := @1522 @2 +@1530 := (b : @1507) -> @13 @1508 @1506 +@1531 := @1527 @1330 +@1533 := @13 @1505 @1506 +@1534 := @851 @1332 +@1536 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_3 @1332 +@1538 := @62 @1534 @61 +@1540 := @62 @1505 @1538 +@1542 := @62 @1377 @1540 +@1544 := @62 @1335 @1542 +@1545 := @66 @854 +@1546 := @1545 @65 +@1547 := @66 @1506 +@1548 := @1547 @1546 +@1549 := @66 @1380 +@1550 := @1549 @1548 +@1551 := @66 @1336 +@1552 := @1551 @1550 +@1553 := @172 @1534 +@1555 := @851 (@1331 @25) +@1568 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @1555 @27) -> (hs : @176) -> @94 (@62 (@851 (@1331 @102)) @25) @122 +@1569 := @1553 @854 +@1571 := @851 (@1331 @27) +@1573 := @13 @1571 @854 +@1578 := @94 (@62 (@851 (@1331 @104)) @25) +@1579 := @1545 @27 +@1584 := {vs : @98} -> {ts : @99} -> (h : @1573) -> (hs : @176) -> @1578 @1579 +@1585 := @1569 @61 +@1587 := @851 (@1331 @29) +@1589 := @13 @1587 @854 +@1591 := @62 @1555 @61 +@1596 := {ts : @99} -> (h : @1589) -> (hs : @217) -> @94 @1591 @1579 +@1597 := @1585 @65 +@1599 := @13 @1534 @854 +@1601 := @62 @1571 @61 +@1602 := @94 @1601 +@1605 := (h : @1599) -> (hs : @96) -> @1602 @1546 +@1606 := @1597 @1536 +@1608 := @62 @1587 @61 +@1610 := @94 @1608 @1546 +@1611 := (hs : @96) -> @1610 +@1612 := @1606 @93 +@1614 := @94 @1538 @1546 +@1615 := @172 @1505 +@1617 := @1504 (@1329 @25) +@1630 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @1617 @27) -> (hs : @176) -> @94 (@62 (@1504 (@1329 @102)) @25) @122 +@1631 := @1615 @1506 +@1633 := @1504 (@1329 @27) +@1635 := @13 @1633 @1506 +@1640 := @94 (@62 (@1504 (@1329 @104)) @25) +@1641 := @1547 @27 +@1646 := {vs : @98} -> {ts : @99} -> (h : @1635) -> (hs : @176) -> @1640 @1641 +@1647 := @1631 @1538 +@1649 := @1504 (@1329 @29) +@1651 := @13 @1649 @1506 +@1652 := @1602 @29 +@1654 := @62 @1617 @1591 +@1659 := {ts : @99} -> (h : @1651) -> (hs : @1652) -> @94 @1654 @1641 +@1660 := @1647 @1546 +@1662 := @62 @1633 @1601 +@1663 := @94 @1662 +@1666 := (h : @1533) -> (hs : @1610) -> @1663 @1548 +@1667 := @1660 @1531 +@1669 := @62 @1649 @1608 +@1671 := @94 @1669 @1548 +@1672 := (hs : @1614) -> @1671 +@1673 := @1667 @1612 +@1675 := @94 @1540 @1548 +@1676 := @172 @1377 +@1678 := @1376 (@1327 @25) +@1691 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @1678 @27) -> (hs : @176) -> @94 (@62 (@1376 (@1327 @102)) @25) @122 +@1692 := @1676 @1380 +@1694 := @1376 (@1327 @27) +@1696 := @13 @1694 @1380 +@1701 := @94 (@62 (@1376 (@1327 @104)) @25) +@1702 := @1549 @27 +@1707 := {vs : @98} -> {ts : @99} -> (h : @1696) -> (hs : @176) -> @1701 @1702 +@1708 := @1692 @1540 +@1710 := @1376 (@1327 @29) +@1712 := @13 @1710 @1380 +@1713 := @1663 @29 +@1715 := @62 @1678 @1654 +@1720 := {ts : @99} -> (h : @1712) -> (hs : @1713) -> @94 @1715 @1702 +@1721 := @1708 @1548 +@1723 := @62 @1694 @1662 +@1724 := @94 @1723 +@1727 := (h : @1503) -> (hs : @1671) -> @1724 @1550 +@1728 := @1721 @1501 +@1730 := @62 @1710 @1669 +@1732 := @94 @1730 @1550 +@1733 := (hs : @1675) -> @1732 +@1734 := @1728 @1673 +@1736 := @94 @1542 @1550 +@1737 := @172 @1335 +@1739 := @1334 (@1325 @25) +@1752 := {t : @58} -> + {vs : @98} -> + {ts : @99} -> (h : @13 @1739 @27) -> (hs : @176) -> @94 (@62 (@1334 (@1325 @102)) @25) @122 +@1753 := @1737 @1336 +@1755 := @1334 (@1325 @27) +@1757 := @13 @1755 @1336 +@1762 := @94 (@62 (@1334 (@1325 @104)) @25) +@1763 := @1551 @27 +@1768 := {vs : @98} -> {ts : @99} -> (h : @1757) -> (hs : @176) -> @1762 @1763 +@1769 := @1753 @1542 +@1771 := @1334 (@1325 @29) +@1773 := @13 @1771 @1336 +@1774 := @1724 @29 +@1776 := @62 @1739 @1715 +@1781 := {ts : @99} -> (h : @1773) -> (hs : @1774) -> @94 @1776 @1763 +@1782 := @1769 @1550 +@1784 := @62 @1755 @1723 +@1785 := @94 @1784 +@1788 := (h : @1369) -> (hs : @1732) -> @1785 @1552 +@1789 := @1782 @1367 +@1791 := @62 @1771 @1730 +@1793 := @94 @1791 @1552 +@1794 := (hs : @1736) -> @1793 +@1795 := @1789 @1734 +@1797 := @94 @1544 @1552 +@1798 := @302 @1320 +@1799 := @274 @1320 +@1808 := {k : @24} -> + {fs : @98} -> {tys : @99} -> (h : @244 (@1799 @27) @252) -> (hf : @176) -> @303 @1321 +@1809 := @1798 @9 +@1810 := @1799 @9 +@1811 := @244 @1810 +@1812 := @1811 @252 +@1817 := {fs : @98} -> {tys : @99} -> (h : @1812) -> (hf : @176) -> @328 @1321 +@1818 := @1809 @1544 +@1825 := {tys : @99} -> (h : @1812) -> (hf : @1785 @29) -> @13 (@326 @1776) @1321 +@1826 := @1818 @1552 +@1833 := (h : @1811 (@251 @1552)) -> (hf : @1793) -> @13 (@326 @1784) @1321 +@1835 := @1826 (@351 @1810) +@1839 := (hf : @1797) -> @13 (@326 @1791) @1321 +@1840 := @1835 @1795 +@1843 := @13 (@326 @1544) @1321 +@1844 := fun (__s : @1317) => @1840 +@1845 := @52 @29 +@1846 := @502 @57 +@1850 := Prod.mk.{0, 0} @24 @57 @9 +@1851 := @1850 @214 +@1852 := @59 @1846 +@1853 := @60 @1846 +@1855 := @1853 @1851 @1852 +@1856 := Bool.true +@1857 := LexLeanTarget.TargetSyntax.Function +@1858 := LexLeanTarget.TargetSyntax.Program.functions +@1859 := @1858 @0 +@1860 := @59 @24 +@1861 := LexLeanTarget.TargetSyntax.Ty.unit +@1862 := LexLeanTarget.TargetSyntax.Value.unit +@1865 := LexLeanTarget.TargetSyntax.Expr.value @1861 @1862 +@1870 := LexLeanTarget.TargetSyntax.Function.mk @1860 @65 @1861 @1865 +@1875 := List.getD.{0} @1857 @1859 @9 @1870 +@1879 := fun (__e_n : @24) => + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.root @4 @9 +@1880 := @172 @214 +@1882 := @13 @203 @27 +@1883 := @18 @100 +@1884 := @62 @1883 +@1892 := {t : @58} -> {vs : @98} -> {ts : @99} -> (h : @1882) -> (hs : @176) -> @94 (@1884 @25) @122 +@1893 := @1880 @20 +@1899 := {vs : @98} -> {ts : @99} -> (h : @187 @20) -> (hs : @176) -> @192 @207 +@1900 := @1893 @61 +@1901 := @204 @61 +@1902 := @94 @1901 +@1906 := {ts : @99} -> (h : @202) -> (hs : @217) -> @1902 @207 +@1907 := @1900 @65 +@1910 := (h : @216) -> (hs : @96) -> @220 @68 +@1912 := @1907 @1845 @93 +@1913 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.denote +@1914 := @1913 @29 +@1915 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.__fits_0 +@1916 := @1915 @29 +@1919 := @18 (Reasoning.Main.screenDose @29) +@1921 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.root @29 +@1922 := Ne.{1} +@1923 := LexLeanPreservation.Obs +@1924 := @1922 @1923 +@1925 := LexLeanPreservation.Rel +@1928 := @1924 (@1925 @29 @4) +@1929 := LexLeanPreservation.Obs.stuck +@1932 := (f : @1507) -> (v : @57) -> @1928 @1929 +@1934 := LexLeanPreservation.Rust.rel_ne_stuck @1916 +@1940 := (v : @57) -> @1924 (@1925 (@1915 @27) @4) @1929 +@1941 := @1934 @1919 +@1945 := @1924 (@1925 @1916 @1919) @1929 +@1946 := @97 @1846 +@1947 := LexLeanPreservation.Rust.FunSem +@1953 := (n : @24) -> @1947 @392 @114 @108 @4 @100 +@1954 := @242 @1857 +@1955 := @241 @1954 +@1962 := LexLeanRuntime.index (@97 @1857) @1857 (LexLeanRuntime.instIndexableList @1857) +@1966 := @1955 (@1962 (@1858 @392) @100) +@1967 := @250 @1857 +@1968 := @1967 @102 +@1969 := @1966 @1968 +@1973 := @69 @400 @392 @114 @102 +@1974 := LexLeanTarget.TargetSyntax.Function.types +@1975 := @1974 @100 +@1976 := @1973 @1975 +@1977 := @242 @1946 +@1978 := @241 @1977 +@1979 := LexLeanTarget.TargetSemantics.bindAll +@1980 := LexLeanTarget.TargetSyntax.Function.parameters +@1985 := @1978 (@1979 (@1980 @108) @100 @1852) +@1986 := @250 @1946 +@1987 := @1986 @102 +@1988 := @1985 @1987 +@1989 := @242 @1507 +@1990 := @241 @1989 +@1991 := LexLeanPreservation.Rust.fnFallible +@1994 := @1990 (@1991 @410 @392) +@1995 := @250 @1507 +@1996 := @1995 @102 +@1997 := @1994 @1996 +@1998 := LexLeanPreservation.RunConv +@1999 := #13 +@2003 := @1998 @1999 @400 @114 @102 +@2005 := @1924 @100 @1929 +@2006 := Exists.{1} +@2007 := LexLeanPreservation.Rust.ROut +@2008 := @2006 @2007 +@2009 := And +@2010 := LexLeanPreservation.Rust.RealizesFn +@2014 := @2009 (@2010 @392 @114 @4) +@2015 := LexLeanPreservation.Rust.RCI +@2017 := @2015 #15 +@2018 := LexLeanPreservation.Rust.fnIdent +@2019 := @2018 @1999 +@2026 := (hne : @2005) -> @2008 (fun (ro : @2007) => @2014 (@2017 @2019 @410 @4)) +@2041 := {p : @21} -> + {c : @22} -> + {A : @23} -> + {f : @24} -> + {fn : @1857} -> + {args : @98} -> + {env : @1946} -> + {F : @1507} -> + {o : @1923} -> + (hB : @1953) -> + (hfn : @1969) -> (hwt : @1976) -> (hbind : @1988) -> (hF : @1997) -> (hA : @2003) -> @2026 +@2043 := LexLeanPreservation.Rust.compose @0 +@2044 := @1947 @0 +@2049 := (n : @24) -> @2044 @114 @108 @4 @100 +@2050 := @1962 @1859 +@2053 := @1955 (@2050 @100) @1968 +@2057 := @80 @392 @114 @102 @1975 +@2058 := @1998 @0 +@2061 := @2058 @400 @114 @102 +@2075 := {c : @22} -> + {A : @23} -> + {f : @24} -> + {fn : @1857} -> + {args : @98} -> + {env : @1946} -> + {F : @1507} -> + {o : @1923} -> + (hB : @2049) -> + (hfn : @2053) -> (hwt : @2057) -> (hbind : @1988) -> (hF : @1997) -> (hA : @2061) -> @2026 +@2076 := @2043 @1 +@2077 := @2044 @1 +@2081 := (n : @24) -> @2077 @108 @4 @100 +@2084 := @88 @114 @102 @1975 +@2085 := @1991 @1 +@2088 := @1990 (@2085 @392) @1996 +@2089 := @2015 @1 +@2099 := (hbind : @1988) -> + (hF : @2088) -> + (hA : @2061) -> (hne : @2005) -> @2008 (fun (ro : @2007) => @2014 (@2089 @2019 @410 @4)) +@2109 := {A : @23} -> + {f : @24} -> + {fn : @1857} -> + {args : @98} -> + {env : @1946} -> + {F : @1507} -> {o : @1923} -> (hB : @2081) -> (hfn : @2053) -> (hwt : @2084) -> @2099 +@2110 := @2076 @2 +@2112 := @2077 @2 @4 +@2114 := (n : @24) -> @2112 @100 +@2115 := @94 @102 +@2116 := @2115 @1975 +@2125 := {f : @24} -> + {fn : @1857} -> + {args : @98} -> + {env : @1946} -> + {F : @1507} -> {o : @1923} -> (hB : @2114) -> (hfn : @2053) -> (hwt : @2116) -> @2099 +@2126 := @2110 @9 +@2128 := (n : @24) -> @2112 @9 +@2129 := @2050 @9 +@2130 := @1955 @2129 +@2131 := @2130 @1968 +@2132 := @2085 @9 +@2133 := @1990 @2132 +@2134 := @2133 @1996 +@2135 := @2058 @9 +@2137 := @2135 @114 @102 +@2139 := @2089 (@2018 @9) +@2147 := (hF : @2134) -> + (hA : @2137) -> (hne : @2005) -> @2008 (fun (ro : @2007) => @2014 (@2139 @410 @4)) +@2156 := {fn : @1857} -> + {args : @98} -> + {env : @1946} -> + {F : @1507} -> + {o : @1923} -> (hB : @2128) -> (hfn : @2131) -> (hwt : @2116) -> (hbind : @1988) -> @2147 +@2157 := @2126 @1875 +@2159 := @2130 (@1967 @1875) +@2160 := @1974 @1875 +@2161 := @2115 @2160 +@2163 := @1979 (@1980 @1875) +@2175 := {args : @98} -> + {env : @1946} -> + {F : @1507} -> + {o : @1923} -> + (hB : @2128) -> + (hfn : @2159) -> (hwt : @2161) -> (hbind : @1978 (@2163 @100 @1852) @1987) -> @2147 +@2176 := @2157 @234 +@2177 := @1884 @61 +@2179 := @94 @2177 @2160 +@2182 := @62 (@18 @108) @61 +@2186 := @1978 (@2163 @2182 @1852) @1987 +@2189 := @62 (@18 @392) @61 +@2210 := {env : @1946} -> + {F : @1507} -> + {o : @1923} -> + (hB : @2128) -> + (hfn : @2159) -> + (hwt : @2179) -> + (hbind : @2186) -> + (hF : @2134) -> + (hA : @2135 @2189 @102) -> + (hne : @2005) -> @2008 (fun (ro : @2007) => @2014 (@2139 (@62 (@18 #12) @61) @4)) +@2211 := @2176 @1855 +@2212 := @190 @61 +@2214 := @94 @2212 @2160 +@2222 := @1978 (@2163 @2177 @1852) (@1986 (@1853 (@1850 @1883) @1852)) +@2225 := @62 (@18 @114) @61 +@2244 := {F : @1507} -> + {o : @1923} -> + (hB : @2128) -> + (hfn : @2159) -> + (hwt : @2214) -> + (hbind : @2222) -> + (hF : @2134) -> + (hA : @2135 @2225 @102) -> + (hne : @2005) -> @2008 (fun (ro : @2007) => @2014 (@2139 (@62 (@18 @410) @61) @4)) +@2245 := @2211 @1856 +@2246 := @1902 @2160 +@2254 := @1978 (@2163 @2212 @1852) (@1986 (@1853 (@1850 @189) @1852)) +@2256 := @2133 (@1995 @1856) +@2258 := @2135 @2182 @102 +@2259 := @2010 @1856 +@2278 := {o : @1923} -> + (hB : @2128) -> + (hfn : @2159) -> + (hwt : @2246) -> + (hbind : @2254) -> + (hF : @2256) -> + (hA : @2258) -> + (hne : @2005) -> @2008 (fun (ro : @2007) => @2009 (@2259 @114 @4) (@2139 (@62 (@18 @400) @61) @4)) +@2279 := @2245 @1914 +@2280 := @220 @2160 +@2288 := @1978 (@2163 @1901 @1852) (@1986 (@1853 (@1850 @203) @1852)) +@2289 := @2135 @2177 +@2290 := @1913 @100 +@2291 := @2289 @2290 +@2292 := @1913 @108 +@2310 := (hB : @2128) -> + (hfn : @2159) -> + (hwt : @2280) -> + (hbind : @2288) -> + (hF : @2256) -> + (hA : @2291) -> + (hne : @1924 @2292 @1929) -> + @2008 (fun (ro : @2007) => @2009 (@2259 (@1913 @392) @4) (@2139 @2189 @4)) +@2311 := @2279 @1879 +@2312 := @228 @2160 +@2320 := @1978 (@2163 @219 @1852) (@1986 (@1853 (@1850 @186) @1852)) +@2321 := @2135 @2212 +@2322 := @1913 @102 +@2340 := (hfn : @2159) -> + (hwt : @2312) -> + (hbind : @2320) -> + (hF : @2256) -> + (hA : @2321 @2322) -> + (hne : @1924 @2290 @1929) -> + @2008 (fun (ro : @2007) => @2009 (@2259 (@1913 @114) @4) (@2139 @2225 @4)) +@2343 := @2311 (@350 @1954 @2129) +@2344 := @235 @2160 +@2352 := @1978 (@2163 @227 @1852) (@1986 (@1853 (@1850 @200) @1852)) +@2353 := @2135 @1901 +@2354 := @1913 @104 +@2370 := (hwt : @2344) -> + (hbind : @2352) -> + (hF : @2256) -> + (hA : @2353 @2354) -> + (hne : @1924 @2322 @1929) -> @2008 (fun (ro : @2007) => @2009 (@2259 @2292 @4) (@2139 @2182 @4)) +@2371 := @2343 @1912 +@2373 := @2163 @234 @1852 +@2376 := @1978 @2373 (@1986 @1855) +@2377 := @2135 @219 +@2378 := @1913 @25 +@2393 := (hbind : @2376) -> + (hF : @2256) -> + (hA : @2377 @2378) -> + (hne : @1924 @2354 @1929) -> @2008 (fun (ro : @2007) => @2009 (@2259 @2290 @4) (@2139 @2177 @4)) +@2396 := @2371 (@350 @1977 @2373) +@2397 := @2135 @227 +@2398 := @1913 @27 +@2412 := (hF : @2256) -> + (hA : @2397 @2398) -> + (hne : @1924 @2378 @1929) -> @2008 (fun (ro : @2007) => @2009 (@2259 @2322 @4) (@2139 @2212 @4)) +@2415 := @2396 (@350 @1989 @2132) +@2429 := (hA : @2135 @234 @1914) -> + (hne : @1924 @2398 @1929) -> @2008 (fun (ro : @2007) => @2009 (@2259 @2354 @4) (@2139 @1901 @4)) +@2430 := @2415 @1921 +@2441 := (hne : @1924 @1914 @1929) -> + @2008 (fun (ro : @2007) => @2009 (@2259 @2378 @4) (@2139 @219 @4)) +@2442 := @2430 @1941 +@2448 := @2009 (@2259 @2398 @4) (@2139 @227 @4) +@2450 := @2008 (fun (ro : @2007) => @2448) +@2452 := @2008 (fun (__e_ro : @2007) => @2448) +@2454 := LexLeanPreservation.Rust.RepresentableL @64 +@2455 := (__e_hrep : @2454) -> @2452 +@2456 := fun (__e_hrep : @2454) => @2442 +@2457 := (w : @24) -> @2455 +@2458 := fun (w : @24) => @2456 +\end{coremodule} +\end{lexlean} diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R7/Compose/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R7/Compose/RustStd.lean deleted file mode 100644 index 523212e6c..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R7/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7 -import LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd -import LexLeanPreservation.Compose -set_option autoImplicit false -set_option maxRecDepth 100000 -set_option maxHeartbeats 0 -set_option synthInstance.maxHeartbeats 0 -set_option linter.unusedVariables false -namespace LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Reasoning.Budget.Spend.Step Nat)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.program _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.krate _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.flags (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.__enc_0 __v) (.adt 0) - | Reasoning.Budget.Spend.Step.Tick => _root_.LexLeanPreservation.Rust.wt_adt rfl _root_.LexLeanPreservation.Rust.wtl_nil - | Reasoning.Budget.Spend.Step.Burn __x0 => _root_.LexLeanPreservation.Rust.wt_adt rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat __x0) _root_.LexLeanPreservation.Rust.wtl_nil) - -/-- The rendering of the root, invoked on the encoded arguments, realizes -the encoded source result. -/ -theorem root (x : Nat) (__e_hrep : _root_.LexLeanPreservation.Rust.RepresentableL [(_root_.LexLeanTarget.TargetSyntax.Value.nat x)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.denote x) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanTarget.TargetSyntax.Value.nat x)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (_root_.LexLeanPreservation.Rust.wt_nat x) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.root x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R7/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R7/Compose/RustStd.lex.tex new file mode 100644 index 000000000..acc9c2c7e --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R7/Compose/RustStd.lex.tex @@ -0,0 +1,505 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7, + LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.__wt_0 : @18 := @398 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.root : @1017 := @1018 { + all: [LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.program +@1 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.krate +@2 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.flags +@3 := Reasoning.Budget.Spend.Step +@4 := Nat +@5 := @3 @4 +@6 := #0 +@8 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.__enc_0 @6 +@9 := LexLeanPreservation.Rust.WT +@10 := LexLeanTarget.TargetSyntax.Ty.adt +@11 := 0 +@12 := @10 @11 +@13 := @9 @0 +@14 := @13 @1 +@15 := @14 @2 +@17 := @15 @8 @12 +@18 := (__v : @5) -> @17 +@19 := fun (__v : @5) => @17 +@20 := LexLeanTarget.TargetSyntax.Value +@21 := LexLeanTarget.TargetSyntax.Ty +@22 := List.nil.{0} +@23 := List.cons.{0} +@24 := @22 @20 +@25 := @22 @21 +@26 := LexLeanTarget.TargetSyntax.Program +@27 := LexLeanPreservation.Rust.RCrate +@28 := LexLeanPreservation.Rust.Flags +@29 := LexLeanPreservation.Rust.WTL +@30 := #2 +@31 := @29 @30 +@32 := #1 +@39 := {p : @26} -> {c : @27} -> {A : @28} -> @31 @32 @6 @24 @25 +@41 := LexLeanPreservation.Rust.wtl_nil @0 +@42 := @29 @0 +@48 := {c : @27} -> {A : @28} -> @42 @32 @6 @24 @25 +@49 := @41 @1 +@50 := @42 @1 +@54 := {A : @28} -> @50 @6 @24 @25 +@55 := @49 @2 +@56 := @50 @2 +@57 := @56 @24 +@58 := @57 @25 +@59 := List.{0} +@60 := @59 @20 +@61 := @59 @21 +@62 := Eq.{1} +@63 := Option.{0} +@64 := @63 @61 +@65 := @62 @64 +@66 := LexLeanPreservation.Rust.adtFields +@67 := #6 +@68 := @66 @67 +@69 := #3 +@72 := @65 (@68 @69 @30) +@73 := Option.some.{0} +@74 := @73 @61 +@75 := @74 @6 +@76 := @72 @75 +@77 := #7 +@79 := @29 @77 @67 +@80 := #5 +@83 := @79 @80 @30 @32 +@84 := #8 +@87 := @9 @84 @77 @67 +@88 := LexLeanTarget.TargetSyntax.Value.adt +@89 := #4 +@91 := @88 @89 @69 +@92 := @87 @91 +@93 := @10 @80 +@103 := {p : @26} -> + {c : @27} -> + {A : @28} -> + {i : @4} -> {k : @4} -> {fs : @60} -> {tys : @61} -> (h : @76) -> (hf : @83) -> @92 @93 +@105 := LexLeanPreservation.Rust.wt_adt @0 +@106 := @66 @0 +@110 := @65 (@106 @69 @30) @75 +@114 := @42 @67 @80 @30 @32 +@126 := {c : @27} -> + {A : @28} -> + {i : @4} -> + {k : @4} -> {fs : @60} -> {tys : @61} -> (h : @110) -> (hf : @114) -> @13 @77 @67 @91 @93 +@127 := @105 @1 +@130 := @50 @80 @30 @32 +@140 := {A : @28} -> + {i : @4} -> {k : @4} -> {fs : @60} -> {tys : @61} -> (h : @110) -> (hf : @130) -> @14 @67 @91 @93 +@141 := @127 @2 +@143 := @56 @30 @32 +@144 := @15 @91 +@151 := {i : @4} -> {k : @4} -> {fs : @60} -> {tys : @61} -> (h : @110) -> (hf : @143) -> @144 @93 +@152 := @141 @11 +@153 := @106 @11 +@162 := {k : @4} -> {fs : @60} -> {tys : @61} -> (h : @65 (@153 @30) @75) -> (hf : @143) -> @144 @12 +@163 := @152 @11 +@164 := @153 @11 +@165 := @65 @164 +@166 := @165 @75 +@167 := @88 @11 +@174 := {fs : @60} -> {tys : @61} -> (h : @166) -> (hf : @143) -> @15 (@167 @69) @12 +@175 := @163 @24 +@176 := @57 @32 +@179 := @15 (@167 @24) @12 +@182 := {tys : @61} -> (h : @166) -> (hf : @176) -> @179 +@183 := @175 @25 +@187 := (h : @165 (@74 @25)) -> (hf : @58) -> @179 +@188 := Eq.refl.{1} +@189 := @188 @64 +@192 := @183 (@189 @164) @55 +@193 := LexLeanTarget.TargetSyntax.Value.nat +@194 := @193 @6 +@195 := LexLeanTarget.TargetSyntax.Ty.nat +@204 := {p : @26} -> {c : @27} -> {A : @28} -> (n : @4) -> @9 @69 @30 @32 @194 @195 +@206 := LexLeanPreservation.Rust.wt_nat @0 +@213 := {c : @27} -> {A : @28} -> (n : @4) -> @13 @30 @32 @194 @195 +@214 := @206 @1 +@219 := {A : @28} -> (n : @4) -> @14 @32 @194 @195 +@220 := @214 @2 +@222 := @15 @194 @195 +@223 := (n : @4) -> @222 +@224 := @220 @6 +@225 := @23 @20 +@227 := @225 @194 @24 +@228 := @23 @21 +@229 := @228 @195 +@230 := @229 @25 +@235 := @9 @67 @80 @89 @69 @30 +@238 := @29 @84 @77 @67 +@240 := @225 @80 @69 +@241 := @238 @240 +@243 := @228 @89 @30 +@253 := {p : @26} -> + {c : @27} -> + {A : @28} -> + {v : @20} -> {t : @21} -> {vs : @60} -> {ts : @61} -> (h : @235) -> (hs : @83) -> @241 @243 +@255 := LexLeanPreservation.Rust.wtl_cons @0 +@271 := {c : @27} -> + {A : @28} -> + {v : @20} -> + {t : @21} -> + {vs : @60} -> {ts : @61} -> (h : @13 @80 @89 @69 @30) -> (hs : @114) -> @42 @77 @67 @240 @243 +@272 := @255 @1 +@285 := {A : @28} -> + {v : @20} -> + {t : @21} -> {vs : @60} -> {ts : @61} -> (h : @14 @89 @69 @30) -> (hs : @130) -> @50 @67 @240 @243 +@286 := @272 @2 +@296 := {v : @20} -> + {t : @21} -> {vs : @60} -> {ts : @61} -> (h : @15 @69 @30) -> (hs : @143) -> @56 @240 @243 +@297 := @286 @194 +@298 := @193 @69 +@299 := @15 @298 +@300 := @299 @30 +@301 := @193 @80 +@302 := @225 @301 +@304 := @56 (@302 @69) +@310 := {t : @21} -> {vs : @60} -> {ts : @61} -> (h : @300) -> (hs : @143) -> @304 @243 +@311 := @297 @195 +@312 := @193 @30 +@314 := @15 @312 @195 +@315 := @193 @89 +@316 := @225 @315 +@318 := @56 (@316 @69) +@319 := @229 @30 +@324 := {vs : @60} -> {ts : @61} -> (h : @314) -> (hs : @143) -> @318 @319 +@325 := @311 @24 +@326 := @193 @32 +@328 := @15 @326 @195 +@330 := @225 @298 @24 +@331 := @56 @330 +@335 := {ts : @61} -> (h : @328) -> (hs : @176) -> @331 @319 +@336 := @325 @25 +@338 := @225 @312 @24 +@339 := @56 @338 +@342 := (h : @222) -> (hs : @58) -> @339 @230 +@343 := @336 @224 +@345 := @225 @326 @24 +@346 := @56 @345 +@347 := @346 @230 +@348 := (hs : @58) -> @347 +@349 := @343 @55 +@351 := @56 @227 @230 +@352 := 1 +@353 := @152 @352 +@354 := @153 @352 +@355 := @65 @354 +@356 := @355 @75 +@357 := @88 @352 +@364 := {fs : @60} -> {tys : @61} -> (h : @356) -> (hf : @143) -> @15 (@357 @69) @12 +@365 := @353 @227 +@372 := {tys : @61} -> (h : @356) -> (hf : @339 @32) -> @15 (@357 @330) @12 +@373 := @365 @230 +@380 := (h : @355 (@74 @230)) -> (hf : @347) -> @15 (@357 @338) @12 +@382 := @373 (@189 @354) +@386 := (hf : @351) -> @15 (@357 @345) @12 +@387 := @382 @349 +@390 := @15 (@357 @227) @12 +@391 := fun (__x0 : @4) => @387 +@398 := fun (__v : @5) => Reasoning.Budget.Spend.Step.casesOn.{0} @4 @19 @6 @192 @391 +@399 := @220 @32 +@402 := Prod.{0, 0} @4 @20 +@406 := Prod.mk.{0, 0} @4 @20 @11 +@407 := @406 @326 +@408 := @22 @402 +@409 := @23 @402 +@411 := @409 @407 @408 +@412 := Bool.true +@413 := LexLeanTarget.TargetSyntax.Function +@414 := LexLeanTarget.TargetSyntax.Program.functions +@415 := @414 @0 +@416 := @22 @4 +@417 := LexLeanTarget.TargetSyntax.Ty.unit +@418 := LexLeanTarget.TargetSyntax.Value.unit +@421 := LexLeanTarget.TargetSyntax.Expr.value @417 @418 +@426 := LexLeanTarget.TargetSyntax.Function.mk @416 @25 @417 @421 +@431 := List.getD.{0} @413 @415 @11 @426 +@435 := fun (__e_n : @4) => LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.root @6 @11 +@436 := @286 @326 +@438 := @15 @315 @30 +@439 := @193 @67 +@440 := @225 @439 +@448 := {t : @21} -> {vs : @60} -> {ts : @61} -> (h : @438) -> (hs : @143) -> @56 (@440 @69) @243 +@449 := @436 @195 +@455 := {vs : @60} -> {ts : @61} -> (h : @299 @195) -> (hs : @143) -> @304 @319 +@456 := @449 @24 +@457 := @316 @24 +@458 := @56 @457 +@462 := {ts : @61} -> (h : @314) -> (hs : @176) -> @458 @319 +@463 := @456 @25 +@466 := (h : @328) -> (hs : @58) -> @331 @230 +@468 := @463 @399 @55 +@469 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.denote +@470 := @469 @32 +@471 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.__fits_0 +@472 := @471 @32 +@475 := @193 (Reasoning.Main.spendLeft @32) +@477 := LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.root @32 +@478 := Bool +@479 := Ne.{1} +@480 := LexLeanPreservation.Obs +@481 := @479 @480 +@482 := LexLeanPreservation.Rel +@485 := @481 (@482 @32 @6) +@486 := LexLeanPreservation.Obs.stuck +@489 := (f : @478) -> (v : @20) -> @485 @486 +@491 := LexLeanPreservation.Rust.rel_ne_stuck @472 +@497 := (v : @20) -> @481 (@482 (@471 @30) @6) @486 +@498 := @491 @475 +@502 := @481 (@482 @472 @475) @486 +@503 := @59 @402 +@504 := LexLeanPreservation.Rust.FunSem +@505 := #9 +@511 := (n : @4) -> @504 @505 @84 @77 @6 @67 +@512 := @63 @413 +@513 := @62 @512 +@520 := LexLeanRuntime.index (@59 @413) @413 (LexLeanRuntime.instIndexableList @413) +@524 := @513 (@520 (@414 @505) @67) +@525 := @73 @413 +@526 := @525 @80 +@527 := @524 @526 +@528 := #10 +@532 := @29 @528 @505 @84 @80 +@533 := LexLeanTarget.TargetSyntax.Function.types +@534 := @533 @67 +@535 := @532 @534 +@536 := @63 @503 +@537 := @62 @536 +@538 := LexLeanTarget.TargetSemantics.bindAll +@539 := LexLeanTarget.TargetSyntax.Function.parameters +@544 := @537 (@538 (@539 @77) @67 @408) +@545 := @73 @503 +@546 := @545 @80 +@547 := @544 @546 +@548 := @63 @478 +@549 := @62 @548 +@550 := LexLeanPreservation.Rust.fnFallible +@551 := #11 +@554 := @549 (@550 @551 @505) +@555 := @73 @478 +@556 := @555 @80 +@557 := @554 @556 +@558 := LexLeanPreservation.RunConv +@559 := #13 +@563 := @558 @559 @528 @84 @80 +@565 := @481 @67 @486 +@566 := Exists.{1} +@567 := LexLeanPreservation.Rust.ROut +@568 := @566 @567 +@569 := And +@570 := LexLeanPreservation.Rust.RealizesFn +@574 := @569 (@570 @505 @84 @6) +@575 := LexLeanPreservation.Rust.RCI +@577 := @575 #15 +@578 := LexLeanPreservation.Rust.fnIdent +@579 := @578 @559 +@586 := (hne : @565) -> @568 (fun (ro : @567) => @574 (@577 @579 @551 @6)) +@601 := {p : @26} -> + {c : @27} -> + {A : @28} -> + {f : @4} -> + {fn : @413} -> + {args : @60} -> + {env : @503} -> + {F : @478} -> + {o : @480} -> + (hB : @511) -> + (hfn : @527) -> (hwt : @535) -> (hbind : @547) -> (hF : @557) -> (hA : @563) -> @586 +@603 := LexLeanPreservation.Rust.compose @0 +@604 := @504 @0 +@609 := (n : @4) -> @604 @84 @77 @6 @67 +@610 := @520 @415 +@613 := @513 (@610 @67) @526 +@617 := @42 @505 @84 @80 @534 +@618 := @558 @0 +@621 := @618 @528 @84 @80 +@635 := {c : @27} -> + {A : @28} -> + {f : @4} -> + {fn : @413} -> + {args : @60} -> + {env : @503} -> + {F : @478} -> + {o : @480} -> + (hB : @609) -> + (hfn : @613) -> (hwt : @617) -> (hbind : @547) -> (hF : @557) -> (hA : @621) -> @586 +@636 := @603 @1 +@637 := @604 @1 +@641 := (n : @4) -> @637 @77 @6 @67 +@644 := @50 @84 @80 @534 +@645 := @550 @1 +@648 := @549 (@645 @505) @556 +@649 := @575 @1 +@659 := (hbind : @547) -> + (hF : @648) -> (hA : @621) -> (hne : @565) -> @568 (fun (ro : @567) => @574 (@649 @579 @551 @6)) +@669 := {A : @28} -> + {f : @4} -> + {fn : @413} -> + {args : @60} -> + {env : @503} -> {F : @478} -> {o : @480} -> (hB : @641) -> (hfn : @613) -> (hwt : @644) -> @659 +@670 := @636 @2 +@672 := @637 @2 @6 +@674 := (n : @4) -> @672 @67 +@675 := @56 @80 +@676 := @675 @534 +@685 := {f : @4} -> + {fn : @413} -> + {args : @60} -> + {env : @503} -> {F : @478} -> {o : @480} -> (hB : @674) -> (hfn : @613) -> (hwt : @676) -> @659 +@686 := @670 @11 +@688 := (n : @4) -> @672 @11 +@689 := @610 @11 +@690 := @513 @689 +@691 := @690 @526 +@692 := @645 @11 +@693 := @549 @692 +@694 := @693 @556 +@695 := @618 @11 +@697 := @695 @84 @80 +@699 := @649 (@578 @11) +@707 := (hF : @694) -> (hA : @697) -> (hne : @565) -> @568 (fun (ro : @567) => @574 (@699 @551 @6)) +@716 := {fn : @413} -> + {args : @60} -> + {env : @503} -> + {F : @478} -> {o : @480} -> (hB : @688) -> (hfn : @691) -> (hwt : @676) -> (hbind : @547) -> @707 +@717 := @686 @431 +@719 := @690 (@525 @431) +@720 := @533 @431 +@721 := @675 @720 +@723 := @538 (@539 @431) +@735 := {args : @60} -> + {env : @503} -> + {F : @478} -> + {o : @480} -> + (hB : @688) -> (hfn : @719) -> (hwt : @721) -> (hbind : @537 (@723 @67 @408) @546) -> @707 +@736 := @717 @345 +@737 := @440 @24 +@739 := @56 @737 @720 +@742 := @225 (@193 @77) @24 +@746 := @537 (@723 @742 @408) @546 +@749 := @225 (@193 @505) @24 +@770 := {env : @503} -> + {F : @478} -> + {o : @480} -> + (hB : @688) -> + (hfn : @719) -> + (hwt : @739) -> + (hbind : @746) -> + (hF : @694) -> + (hA : @695 @749 @80) -> + (hne : @565) -> @568 (fun (ro : @567) => @574 (@699 (@225 (@193 #12) @24) @6)) +@771 := @736 @411 +@772 := @302 @24 +@774 := @56 @772 @720 +@782 := @537 (@723 @737 @408) (@545 (@409 (@406 @439) @408)) +@785 := @225 (@193 @84) @24 +@804 := {F : @478} -> + {o : @480} -> + (hB : @688) -> + (hfn : @719) -> + (hwt : @774) -> + (hbind : @782) -> + (hF : @694) -> + (hA : @695 @785 @80) -> + (hne : @565) -> @568 (fun (ro : @567) => @574 (@699 (@225 (@193 @551) @24) @6)) +@805 := @771 @412 +@806 := @458 @720 +@814 := @537 (@723 @772 @408) (@545 (@409 (@406 @301) @408)) +@816 := @693 (@555 @412) +@818 := @695 @742 @80 +@819 := @570 @412 +@838 := {o : @480} -> + (hB : @688) -> + (hfn : @719) -> + (hwt : @806) -> + (hbind : @814) -> + (hF : @816) -> + (hA : @818) -> + (hne : @565) -> @568 (fun (ro : @567) => @569 (@819 @84 @6) (@699 (@225 (@193 @528) @24) @6)) +@839 := @805 @470 +@840 := @331 @720 +@848 := @537 (@723 @457 @408) (@545 (@409 (@406 @315) @408)) +@849 := @695 @737 +@850 := @469 @67 +@851 := @849 @850 +@852 := @469 @77 +@870 := (hB : @688) -> + (hfn : @719) -> + (hwt : @840) -> + (hbind : @848) -> + (hF : @816) -> + (hA : @851) -> + (hne : @481 @852 @486) -> @568 (fun (ro : @567) => @569 (@819 (@469 @505) @6) (@699 @749 @6)) +@871 := @839 @435 +@872 := @339 @720 +@880 := @537 (@723 @330 @408) (@545 (@409 (@406 @298) @408)) +@881 := @695 @772 +@882 := @469 @80 +@900 := (hfn : @719) -> + (hwt : @872) -> + (hbind : @880) -> + (hF : @816) -> + (hA : @881 @882) -> + (hne : @481 @850 @486) -> @568 (fun (ro : @567) => @569 (@819 (@469 @84) @6) (@699 @785 @6)) +@903 := @871 (@188 @512 @689) +@904 := @346 @720 +@912 := @537 (@723 @338 @408) (@545 (@409 (@406 @312) @408)) +@913 := @695 @457 +@914 := @469 @89 +@930 := (hwt : @904) -> + (hbind : @912) -> + (hF : @816) -> + (hA : @913 @914) -> + (hne : @481 @882 @486) -> @568 (fun (ro : @567) => @569 (@819 @852 @6) (@699 @742 @6)) +@931 := @903 @468 +@933 := @723 @345 @408 +@936 := @537 @933 (@545 @411) +@937 := @695 @330 +@938 := @469 @69 +@953 := (hbind : @936) -> + (hF : @816) -> + (hA : @937 @938) -> + (hne : @481 @914 @486) -> @568 (fun (ro : @567) => @569 (@819 @850 @6) (@699 @737 @6)) +@956 := @931 (@188 @536 @933) +@957 := @695 @338 +@958 := @469 @30 +@972 := (hF : @816) -> + (hA : @957 @958) -> + (hne : @481 @938 @486) -> @568 (fun (ro : @567) => @569 (@819 @882 @6) (@699 @772 @6)) +@975 := @956 (@188 @548 @692) +@989 := (hA : @695 @345 @470) -> + (hne : @481 @958 @486) -> @568 (fun (ro : @567) => @569 (@819 @914 @6) (@699 @457 @6)) +@990 := @975 @477 +@1001 := (hne : @481 @470 @486) -> @568 (fun (ro : @567) => @569 (@819 @938 @6) (@699 @330 @6)) +@1002 := @990 @498 +@1008 := @569 (@819 @958 @6) (@699 @338 @6) +@1010 := @568 (fun (ro : @567) => @1008) +@1012 := @568 (fun (__e_ro : @567) => @1008) +@1014 := LexLeanPreservation.Rust.RepresentableL @227 +@1015 := (__e_hrep : @1014) -> @1012 +@1016 := fun (__e_hrep : @1014) => @1002 +@1017 := (x : @4) -> @1015 +@1018 := fun (x : @4) => @1016 +\end{coremodule} +\end{lexlean} diff --git a/examples/reasoning/expected/verify/preserve/audit.txt b/examples/reasoning/expected/verify/preserve/audit.txt index c29e9a669..3c882db36 100644 --- a/examples/reasoning/expected/verify/preserve/audit.txt +++ b/examples/reasoning/expected/verify/preserve/audit.txt @@ -7793,6 +7793,31 @@ 'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_3' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_4' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_3' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_3' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.__wt_0' depends on axioms: [propext] -- statement vocabulary inductive LexLeanPreservation.Obs : Type number of parameters: 0 diff --git a/examples/reasoning/expected/verify/preserve/preservation.json b/examples/reasoning/expected/verify/preserve/preservation.json index fbe7da59d..a3832a9f9 100644 --- a/examples/reasoning/expected/verify/preserve/preservation.json +++ b/examples/reasoning/expected/verify/preserve/preservation.json @@ -1 +1 @@ -{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":141533,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0","program":{"byte_length":36186,"sha256":"3f39f0a6f1b7639eb1a021d09aa351a8a51cde520fe0d8fcb48317283f1e3d63"},"renderings":[{"byte_length":187486,"composed":{"byte_length":6698,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore","sha256":"94bafb37efcc4de3bd8a7077ff954fe4264826022dafda0dd2cbca1801dad3da","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.root"},"crate":{"byte_length":25957,"sha256":"373227b883bed3b90092ff7c99c97a8a2479213d7c773852355fff7648beaf0e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore","sha256":"b3292aeb8d96397f1b7b2b594742355573025c1afe94a3930c7e9250640c1ae9","target":"rust-core","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.root"}],"root":"Reasoning.Main.triageLevel","sha256":"ef5ec5c38219330c4ca962218877620efc25cd79931b22cbb99a29062471cf07","targets":["rust-core"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.root"},{"byte_length":143432,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1","program":{"byte_length":36679,"sha256":"9e2f7386e9b0f0c3f8861e9e54bba15353cc8c7b465664f5e992b8210e83815f"},"renderings":[{"byte_length":188860,"composed":{"byte_length":6698,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore","sha256":"80d1c5d683764796c8ff37ff37cc4f8e48cb361f7ef6596a58c6cff8250fec2b","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.root"},"crate":{"byte_length":26098,"sha256":"ac88de1419f5c1f6ed9e589a800cfc4afcf42b55c77f46b29c439164d44f68c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore","sha256":"98f520e85458da841cd92d9b38bc42041e0c499297397711a70572c438941e07","target":"rust-core","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.root"}],"root":"Reasoning.Main.gatewayLevel","sha256":"28a28aff1df4a948ec949df7dac5f5d027cd0880c00cc59d4d2eed8bfb01867b","targets":["rust-core"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.root"},{"byte_length":189369,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2","program":{"byte_length":47876,"sha256":"2a46e167d6afdf96fd1c4ed4ddd462c30eb1ab849e08b0847f3c4aa87ab5fd0a"},"renderings":[{"byte_length":283431,"composed":{"byte_length":8531,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd","sha256":"65eebae5d5f2a49fe321837d9fa04c88576427f999262eb3c1addc4bf4b15d89","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.root"},"crate":{"byte_length":45349,"sha256":"5cdcbdf73202f418deae91f5ed3daf71e8457190441c122784ee1fa157a61251"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd","sha256":"e358225e2a8e1ae60cfff8d5e7ee0d862d949d9335f28cbf5123a7389396be70","target":"rust-std","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.root"}],"root":"Reasoning.Main.triageSteps","sha256":"271092ab4b8ae3d66ea97066255ad3828a9c0eb7d56e317e48f8a642f6d63409","targets":["rust-std"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.root"},{"byte_length":153403,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3","program":{"byte_length":41744,"sha256":"9a5f37cae3bc362991271aa26ace2db53c7ca9c38618a34455fbc70882ae476d"},"renderings":[{"byte_length":230142,"composed":{"byte_length":5565,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd","sha256":"94fb9311c3849cda2e6c6a71286e269723e604aea52954f8235ed37e9061daa5","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.root"},"crate":{"byte_length":39550,"sha256":"b66e8320820654694b9a745a745a90017dcfa9a7713e85d44d8257fd7d3d9c51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd","sha256":"3040c2e7797567daaa6d462a9a5e030a1b3f23b790ddfec0d418b19bc4f56498","target":"rust-std","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.root"}],"root":"Reasoning.Main.planLeft","sha256":"dc36866c6add14a77355ee87f161623f06dddb1f5df0fc1b78bf164f28ce18cf","targets":["rust-std"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.root"},{"byte_length":42541,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4","program":{"byte_length":11798,"sha256":"3a65f411f6eb41c898bd2f895719b295fbc8afaefc20212dfc8e111f582a3db5"},"renderings":[{"byte_length":62656,"composed":{"byte_length":3403,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd","sha256":"20c9e8f44ecfc88941271eeff18bda9b263fad0f4e81f71cf9f3b8b989777e61","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.root"},"crate":{"byte_length":20147,"sha256":"7ffb7b92f94e45432a616d2778e61294d980f58e03d30392ae519e3002aaa41b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd","sha256":"1e31b7d03377bad3ed695bc53569440b4327226c3f994f82e7ff05430457d17c","target":"rust-std","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.root"}],"root":"Reasoning.Main.doseLevel","sha256":"0a70362d06e29d5353f0fff01b54a1ec7da78f5ed14e104f27a5285b1f0b8b84","targets":["rust-std"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.root"},{"byte_length":130194,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5","program":{"byte_length":33983,"sha256":"96c393acd11d0f45f881f960db3eba8734d1115aa71b0b73b3e73d13f08a0488"},"renderings":[{"byte_length":175999,"composed":{"byte_length":6671,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore","sha256":"023184a2d59c30f591af25df25c0b2fc2856767320c86c85f4abbab05e583f77","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.root"},"crate":{"byte_length":24856,"sha256":"e759aefcfa353eb5202d08cc08c7dcc378cd0994d8be42bca802c174d340d28d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore","sha256":"3f34480cd1677cd7e25d102d6320707ef406d74292fb081e7147757886f2ffa9","target":"rust-core","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.root"}],"root":"Reasoning.Main.gradeLevel","sha256":"4c086c0e9c320c8fc6d81606254b758a76ae01db9f647d6c3b0983e117e3123a","targets":["rust-core"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.root"},{"byte_length":115327,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6","program":{"byte_length":28344,"sha256":"8c9c2a16fb25398ae97777f69e934175246b5e37acece648c6661c6f3dfc7282"},"renderings":[{"byte_length":164251,"composed":{"byte_length":4998,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd","sha256":"a9eb4d2ac3591cbbbe1eb27d59cf503ff8188bd32a91d58a456c5d615f80f297","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.root"},"crate":{"byte_length":32915,"sha256":"224dabc5daa77c8128eb9d49f2dcd528155354328a75b0129ec1818f247b918c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd","sha256":"07d71e2e5214bd98875fa3c0feaa7ceb5bcbc0eecd345d112e52eacd3adb6710","target":"rust-std","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.root"}],"root":"Reasoning.Main.screenDose","sha256":"73966392b6fb465021fe98435b3e731ab0dbfbde5762eb9d4ab5418e9bd6e247","targets":["rust-std"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.root"},{"byte_length":60908,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7","program":{"byte_length":16614,"sha256":"bf95bba329a7f73d9a7036f8fd91df829a4b615b2c3a7249c9998238687ecfee"},"renderings":[{"byte_length":57695,"composed":{"byte_length":2228,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd","sha256":"3f9658affd30526f74e433f213df2c4cde7a4db59a3a0325577b48810cd185af","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.root"},"crate":{"byte_length":18308,"sha256":"2d2db53b580aa55f9a76a185cbcde3ca8a0689b2607c2f3fc11e2b94fb89ac8d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd","sha256":"b9376b70afd82a58393cf76078d639659279bb3ce24250b811bda109ca89a534","target":"rust-std","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.root"}],"root":"Reasoning.Main.spendLeft","sha256":"aba2dd6df3b437bfec527349f171fc61ee59138a01e0812020386b65eb2ed227","targets":["rust-std"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":141533,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0","program":{"byte_length":36186,"sha256":"3f39f0a6f1b7639eb1a021d09aa351a8a51cde520fe0d8fcb48317283f1e3d63"},"renderings":[{"byte_length":187486,"composed":{"byte_length":40145,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore","sha256":"aea5c891d5d8fa50126c38bc8a1df90e7dff3dbc33c0d854ab3e900d01ae7ebf","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.root"},"crate":{"byte_length":25957,"sha256":"373227b883bed3b90092ff7c99c97a8a2479213d7c773852355fff7648beaf0e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore","sha256":"b3292aeb8d96397f1b7b2b594742355573025c1afe94a3930c7e9250640c1ae9","target":"rust-core","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.root"}],"root":"Reasoning.Main.triageLevel","sha256":"ef5ec5c38219330c4ca962218877620efc25cd79931b22cbb99a29062471cf07","targets":["rust-core"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.root"},{"byte_length":143432,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1","program":{"byte_length":36679,"sha256":"9e2f7386e9b0f0c3f8861e9e54bba15353cc8c7b465664f5e992b8210e83815f"},"renderings":[{"byte_length":188860,"composed":{"byte_length":40146,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore","sha256":"b0ea06a795f8049dc8d2bf04d38c823def13372d9d0afedee15d60c44be3ffe4","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.root"},"crate":{"byte_length":26098,"sha256":"ac88de1419f5c1f6ed9e589a800cfc4afcf42b55c77f46b29c439164d44f68c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore","sha256":"98f520e85458da841cd92d9b38bc42041e0c499297397711a70572c438941e07","target":"rust-core","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.root"}],"root":"Reasoning.Main.gatewayLevel","sha256":"28a28aff1df4a948ec949df7dac5f5d027cd0880c00cc59d4d2eed8bfb01867b","targets":["rust-core"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.root"},{"byte_length":189369,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2","program":{"byte_length":47876,"sha256":"2a46e167d6afdf96fd1c4ed4ddd462c30eb1ab849e08b0847f3c4aa87ab5fd0a"},"renderings":[{"byte_length":283431,"composed":{"byte_length":52908,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd","sha256":"ac1f4ba1d5f52031c634d6e4982c859d9c0ca5a36144480552aea384c9bc8a62","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.root"},"crate":{"byte_length":45349,"sha256":"5cdcbdf73202f418deae91f5ed3daf71e8457190441c122784ee1fa157a61251"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd","sha256":"e358225e2a8e1ae60cfff8d5e7ee0d862d949d9335f28cbf5123a7389396be70","target":"rust-std","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.root"}],"root":"Reasoning.Main.triageSteps","sha256":"271092ab4b8ae3d66ea97066255ad3828a9c0eb7d56e317e48f8a642f6d63409","targets":["rust-std"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.root"},{"byte_length":153403,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3","program":{"byte_length":41744,"sha256":"9a5f37cae3bc362991271aa26ace2db53c7ca9c38618a34455fbc70882ae476d"},"renderings":[{"byte_length":230142,"composed":{"byte_length":40309,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd","sha256":"bf05a64fe5659f7789884bb9cb8053bc1d268177a0a6b346e8ac2465ee778d3f","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.root"},"crate":{"byte_length":39550,"sha256":"b66e8320820654694b9a745a745a90017dcfa9a7713e85d44d8257fd7d3d9c51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd","sha256":"3040c2e7797567daaa6d462a9a5e030a1b3f23b790ddfec0d418b19bc4f56498","target":"rust-std","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.root"}],"root":"Reasoning.Main.planLeft","sha256":"dc36866c6add14a77355ee87f161623f06dddb1f5df0fc1b78bf164f28ce18cf","targets":["rust-std"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.root"},{"byte_length":42541,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4","program":{"byte_length":11798,"sha256":"3a65f411f6eb41c898bd2f895719b295fbc8afaefc20212dfc8e111f582a3db5"},"renderings":[{"byte_length":62656,"composed":{"byte_length":26344,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd","sha256":"37986428d21c4c1667f2fd820122d4d10e3174f0fc88939ede1f29648f2ba647","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.root"},"crate":{"byte_length":20147,"sha256":"7ffb7b92f94e45432a616d2778e61294d980f58e03d30392ae519e3002aaa41b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd","sha256":"1e31b7d03377bad3ed695bc53569440b4327226c3f994f82e7ff05430457d17c","target":"rust-std","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.root"}],"root":"Reasoning.Main.doseLevel","sha256":"0a70362d06e29d5353f0fff01b54a1ec7da78f5ed14e104f27a5285b1f0b8b84","targets":["rust-std"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.root"},{"byte_length":130194,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5","program":{"byte_length":33983,"sha256":"96c393acd11d0f45f881f960db3eba8734d1115aa71b0b73b3e73d13f08a0488"},"renderings":[{"byte_length":175999,"composed":{"byte_length":40138,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore","sha256":"68fab836f68905cd199e3be1453df4f0fc8a8f869c0e17142bbe935da8015985","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.root"},"crate":{"byte_length":24856,"sha256":"e759aefcfa353eb5202d08cc08c7dcc378cd0994d8be42bca802c174d340d28d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore","sha256":"3f34480cd1677cd7e25d102d6320707ef406d74292fb081e7147757886f2ffa9","target":"rust-core","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.root"}],"root":"Reasoning.Main.gradeLevel","sha256":"4c086c0e9c320c8fc6d81606254b758a76ae01db9f647d6c3b0983e117e3123a","targets":["rust-core"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.root"},{"byte_length":115327,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6","program":{"byte_length":28344,"sha256":"8c9c2a16fb25398ae97777f69e934175246b5e37acece648c6661c6f3dfc7282"},"renderings":[{"byte_length":164251,"composed":{"byte_length":37686,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd","sha256":"1c7598eee6d2c49b92b1cdce838fd6594800b62d249a88bccfb919bab37cc146","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.root"},"crate":{"byte_length":32915,"sha256":"224dabc5daa77c8128eb9d49f2dcd528155354328a75b0129ec1818f247b918c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd","sha256":"07d71e2e5214bd98875fa3c0feaa7ceb5bcbc0eecd345d112e52eacd3adb6710","target":"rust-std","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.root"}],"root":"Reasoning.Main.screenDose","sha256":"73966392b6fb465021fe98435b3e731ab0dbfbde5762eb9d4ab5418e9bd6e247","targets":["rust-std"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.root"},{"byte_length":60908,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7","program":{"byte_length":16614,"sha256":"bf95bba329a7f73d9a7036f8fd91df829a4b615b2c3a7249c9998238687ecfee"},"renderings":[{"byte_length":57695,"composed":{"byte_length":15068,"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd","sha256":"967bda65f512f012a7d562da75fd917085e803c7ea141fd8e3352c9e83b222cd","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.root"},"crate":{"byte_length":18308,"sha256":"2d2db53b580aa55f9a76a185cbcde3ca8a0689b2607c2f3fc11e2b94fb89ac8d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd","sha256":"b9376b70afd82a58393cf76078d639659279bb3ce24250b811bda109ca89a534","target":"rust-std","theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.root"}],"root":"Reasoning.Main.spendLeft","sha256":"aba2dd6df3b437bfec527349f171fc61ee59138a01e0812020386b65eb2ed227","targets":["rust-std"],"theorem":"LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.root"}],"spec":"lexlean/preservation/1"} diff --git a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.Audit.json index 428f02219..6e61511b1 100644 --- a/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.Audit.json +++ b/examples/reasoning/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -1 +1 @@ -{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"5ecb957cb5fecf7fa781cf9bfb47a5ea76b2b76ed29ec53a8ae018af4bf81b1d","tool":"lean"} +{"argv":["env","lean","-R","$STAGING/preserve-src","$STAGING/preserve-src/LexLeanPreserve/Audit.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Audit","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"'LexLeanPreservation.Obs' does not depend on any axioms\n'LexLeanPreservation.obs.match_1' does not depend on any axioms\n'LexLeanPreservation.obs' does not depend on any axioms\n'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ObsL' does not depend on any axioms\n'LexLeanPreservation.obsL.match_1' does not depend on any axioms\n'LexLeanPreservation.obsL' does not depend on any axioms\n'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Obs.casesOn' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.value.elim' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.recOn' does not depend on any axioms\n'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Obs.value.inj' does not depend on any axioms\n'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.recOn' does not depend on any axioms\n'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms\n'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rel' does not depend on any axioms\n'LexLeanPreservation.Rel.eq_1' does not depend on any axioms\n'LexLeanPreservation.RelL' does not depend on any axioms\n'LexLeanPreservation.RelL.eq_1' does not depend on any axioms\n'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.addSteps_ne' does not depend on any axioms\n'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable.match_1_16' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_18' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_20' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_22' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.stable.match_1_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_ne' does not depend on any axioms\n'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_addSteps' does not depend on any axioms\n'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obsL_ne' does not depend on any axioms\n'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.obs.eq_1' does not depend on any axioms\n'LexLeanPreservation.obs.eq_2' does not depend on any axioms\n'LexLeanPreservation.obs.eq_3' does not depend on any axioms\n'LexLeanPreservation.obs.eq_4' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_1' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_2' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_3' does not depend on any axioms\n'LexLeanPreservation.obsL.eq_4' does not depend on any axioms\n'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.ListEnc.elem' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms\n'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms\n'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.OptEnc.elem' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms\n'LexLeanPreservation.encOption.match_1' does not depend on any axioms\n'LexLeanPreservation.encOption' does not depend on any axioms\n'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms\n'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext]\n'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms\n'LexLeanPreservation.construct_adt' does not depend on any axioms\n'LexLeanPreservation.construct_cons' does not depend on any axioms\n'LexLeanPreservation.construct_error' does not depend on any axioms\n'LexLeanPreservation.construct_false' does not depend on any axioms\n'LexLeanPreservation.construct_nil' does not depend on any axioms\n'LexLeanPreservation.construct_none' does not depend on any axioms\n'LexLeanPreservation.construct_ok' does not depend on any axioms\n'LexLeanPreservation.construct_pair' does not depend on any axioms\n'LexLeanPreservation.construct_some' does not depend on any axioms\n'LexLeanPreservation.construct_succ' does not depend on any axioms\n'LexLeanPreservation.construct_true' does not depend on any axioms\n'LexLeanPreservation.construct_unit' does not depend on any axioms\n'LexLeanPreservation.construct_zero' does not depend on any axioms\n'LexLeanPreservation.encExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.encExcept' does not depend on any axioms\n'LexLeanPreservation.encList' does not depend on any axioms\n'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering' does not depend on any axioms\n'LexLeanPreservation.encPair' does not depend on any axioms\n'LexLeanPreservation.encUnit' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.listEnc' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms\n'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms\n'LexLeanPreservation.optEnc' does not depend on any axioms\n'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms\n'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.fromStrings_map' does not depend on any axioms\n'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_map._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_map' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms\n'LexLeanPreservation.listIndex_unique' does not depend on any axioms\n'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.obs_natResult' does not depend on any axioms\n'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms\n'LexLeanPreservation.toStrings_map._f' does not depend on any axioms\n'LexLeanPreservation.toStrings_map' does not depend on any axioms\n'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanRuntime.slice.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms\n'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms\n'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms\n'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms\n'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.divideStep' does not depend on any axioms\n'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.divide_unique._f' does not depend on any axioms\n'LexLeanPreservation.divide_unique' does not depend on any axioms\n'LexLeanPreservation.multiplyStep' does not depend on any axioms\n'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms\n'LexLeanPreservation.multiply_unique._f' does not depend on any axioms\n'LexLeanPreservation.multiply_unique' does not depend on any axioms\n'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ordOf.match_1' does not depend on any axioms\n'LexLeanPreservation.ordOf' does not depend on any axioms\n'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext]\n'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext]\n'LexLeanPreservation.lessThanE' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms\n'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.orderOf_insert' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms\n'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms\n'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms\n'LexLeanPreservation.LookOps' does not depend on any axioms\n'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.LookOps.l0' does not depend on any axioms\n'LexLeanPreservation.LookOps.leq' does not depend on any axioms\n'LexLeanPreservation.LookOps.lgt' does not depend on any axioms\n'LexLeanPreservation.LookOps.llt' does not depend on any axioms\n'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.LookOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps' does not depend on any axioms\n'LexLeanPreservation.SetOps.c0' does not depend on any axioms\n'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.ceq' does not depend on any axioms\n'LexLeanPreservation.SetOps.cgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.clt' does not depend on any axioms\n'LexLeanPreservation.SetOps.i0' does not depend on any axioms\n'LexLeanPreservation.SetOps.ieq' does not depend on any axioms\n'LexLeanPreservation.SetOps.igt' does not depend on any axioms\n'LexLeanPreservation.SetOps.ilt' does not depend on any axioms\n'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.SetOps.r0' does not depend on any axioms\n'LexLeanPreservation.SetOps.recOn' does not depend on any axioms\n'LexLeanPreservation.SetOps.req' does not depend on any axioms\n'LexLeanPreservation.SetOps.rgt' does not depend on any axioms\n'LexLeanPreservation.SetOps.rlt' does not depend on any axioms\n'LexLeanPreservation.TopoOps' does not depend on any axioms\n'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms\n'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms\n'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms\n'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms\n'LexLeanPreservation.Tpl.boolE' does not depend on any axioms\n'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms\n'LexLeanPreservation.Tpl.cns' does not depend on any axioms\n'LexLeanPreservation.Tpl.fn' does not depend on any axioms\n'LexLeanPreservation.Tpl.lst' does not depend on any axioms\n'LexLeanPreservation.Tpl.v' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.pr' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.natOne' does not depend on any axioms\n'LexLeanPreservation.Tpl.nl' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms\n'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.enc_elem' does not depend on any axioms\n'LexLeanPreservation.enc_entry' does not depend on any axioms\n'LexLeanPreservation.foldFits.match_1' does not depend on any axioms\n'LexLeanPreservation.foldFits._f' does not depend on any axioms\n'LexLeanPreservation.foldFits' does not depend on any axioms\n'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.graphFits' does not depend on any axioms\n'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits._f' does not depend on any axioms\n'LexLeanPreservation.iterateFits' does not depend on any axioms\n'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.length_eq' does not depend on any axioms\n'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.reachNext' does not depend on any axioms\n'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.match_1' does not depend on any axioms\n'LexLeanPreservation.untilFits._f' does not depend on any axioms\n'LexLeanPreservation.untilFits' does not depend on any axioms\n'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms\n'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms\n'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms\n'LexLeanPreservation.validExcept.match_1' does not depend on any axioms\n'LexLeanPreservation.InvExcept' does not depend on any axioms\n'LexLeanPreservation.InvList' does not depend on any axioms\n'LexLeanPreservation.InvList.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._f' does not depend on any axioms\n'LexLeanPreservation.StrictAsc' does not depend on any axioms\n'LexLeanPreservation.InvMap' does not depend on any axioms\n'LexLeanPreservation.validOption.match_1' does not depend on any axioms\n'LexLeanPreservation.InvOption' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.InvPair' does not depend on any axioms\n'LexLeanPreservation.InvSet' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms\n'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms\n'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms\n'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms\n'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms\n'LexLeanPreservation.ascMap.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB.match_1' does not depend on any axioms\n'LexLeanPreservation.lessB' does not depend on any axioms\n'LexLeanPreservation.ascMap._f' does not depend on any axioms\n'LexLeanPreservation.ascMap' does not depend on any axioms\n'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.lessB_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.ascSet._f' does not depend on any axioms\n'LexLeanPreservation.ascSet' does not depend on any axioms\n'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms\n'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms\n'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_iff' depends on axioms: [propext]\n'LexLeanPreservation.ascSet_inv' depends on axioms: [propext]\n'LexLeanPreservation.condAnd_iff' depends on axioms: [propext]\n'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms\n'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.lessB.eq_1' does not depend on any axioms\n'LexLeanPreservation.lessB_eq' depends on axioms: [propext]\n'LexLeanPreservation.lessB_gt' depends on axioms: [propext]\n'LexLeanPreservation.lessB_lt' depends on axioms: [propext]\n'LexLeanPreservation.someObs.match_1' does not depend on any axioms\n'LexLeanPreservation.someObs' does not depend on any axioms\n'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList.match_1' does not depend on any axioms\n'LexLeanPreservation.validList._f' does not depend on any axioms\n'LexLeanPreservation.validList' does not depend on any axioms\n'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption' does not depend on any axioms\n'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validPair' does not depend on any axioms\n'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept' does not depend on any axioms\n'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms\n'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.trueIff' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validExcept_inv' does not depend on any axioms\n'LexLeanPreservation.validList._sunfold' does not depend on any axioms\n'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.validList.eq_1' does not depend on any axioms\n'LexLeanPreservation.validList.eq_2' does not depend on any axioms\n'LexLeanPreservation.validList.eq_def' does not depend on any axioms\n'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.validOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.validOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.validOption_inv' depends on axioms: [propext]\n'LexLeanPreservation.validPair_inv' depends on axioms: [propext]\n'LexLeanPreservation.validTrue_inv' does not depend on any axioms\n'LexLeanPreservation.Rust.Ctx' does not depend on any axioms\n'LexLeanPreservation.Rust.Flags' does not depend on any axioms\n'LexLeanPreservation.Rust.RCrate' does not depend on any axioms\n'LexLeanPreservation.Rust.RIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext]\n'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms\n'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms\n'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._f' does not depend on any axioms\n'LexLeanPreservation.Rust.inert' does not depend on any axioms\n'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms\n'LexLeanPreservation.Rust.local_' does not depend on any axioms\n'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ROut' does not depend on any axioms\n'LexLeanPreservation.Rust.Halt' does not depend on any axioms\n'LexLeanPreservation.Rust.REnv' does not depend on any axioms\n'LexLeanPreservation.Rust.RExpr' does not depend on any axioms\n'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RLet' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms\n'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree' does not depend on any axioms\n'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext]\n'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd' does not depend on any axioms\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldB' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms\n'LexLeanPreservation.Rust.okBlock' does not depend on any axioms\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.elseLets' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK' does not depend on any axioms\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.negateR' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.armShape' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered' depends on axioms: [propext]\n'LexLeanPreservation.Rust.scrut' does not depend on any axioms\n'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.validU' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotOK' does not depend on any axioms\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOK' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms\n'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.Fresh' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext]\n'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms\n'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms\n'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext]\n'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms\n'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext]\n'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.split_last' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext]\n'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.itemResult' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext]\n'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms\n'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms\n'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound]\n'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms\n'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms\n'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext]\n'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext]\n'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext]\n'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext]\n'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms\n'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext]\n'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext]\n'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext]\n'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext]\n'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext]\n'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms\n'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms\n'LexLeanPreservation.Rust.fl_of' does not depend on any axioms\n'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms\n'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext]\n'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound]\n'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms\n'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext]\n'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms\n'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext]\n'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext]\n'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms\n'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext]\n'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext]\n'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms\n'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_1' does not depend on any axioms\n'LexLeanPreservation.encOption.eq_2' does not depend on any axioms\n'LexLeanPreservation.encPair.eq_1' does not depend on any axioms\n'LexLeanPreservation.encUnit.eq_1' does not depend on any axioms\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R0.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R1.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_4' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R2.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R3.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R4.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R5.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R6.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.__wt_0' depends on axioms: [propext]\n-- statement vocabulary\ninductive LexLeanPreservation.Obs : Type\nnumber of parameters: 0\nconstructors:\nLexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs\nLexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs\nLexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs\ndef LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs :=\nfun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow\ndef LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program →\n List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop :=\nfun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o\ndef LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p f args o =>\n ∃ fn,\n LexLeanRuntime.index p.functions f = some fn ∧\n ∃ env,\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧\n LexLeanPreservation.Conv p env fn.body o\ndef LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program →\n Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop :=\nfun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o\ndef LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n x.brecOn (LexLeanPreservation.Rust.WT._f p c A)\n (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1\ndef LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.Flags →\n List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop :=\nfun p c A x x_1 =>\n (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f =>\n ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1\n x_1\ndef LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent :=\nfun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f\ndef LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool :=\nfun c f =>\n Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst)\n (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f))\ndef LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate →\n LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop :=\nfun c f args o =>\n o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o\ndef LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fl x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop :=\nfun fallible x x_1 =>\n match x, x_1 with\n | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w =>\n fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error\n | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True\n | x, x_2 => False\ndef LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program →\n LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop :=\nfun p c A n f =>\n ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value)\n (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool),\n LexLeanRuntime.index p.functions f = some fn →\n LexLeanPreservation.Rust.WTL p c A args fn.types →\n LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env →\n LexLeanPreservation.Rust.fnFallible c f = some F →\n ∀ (o : LexLeanPreservation.Obs),\n LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o →\n o ≠ LexLeanPreservation.Obs.stuck →\n (∀ (v : LexLeanTarget.TargetSyntax.Value),\n o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧\n ∃ ro,\n LexLeanPreservation.Rust.RealizesFn F o ro ∧\n LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro\ndef LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs :=\nfun x =>\n match x with\n | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some\n | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow\n | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck\ndef LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f\ndef LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop :=\nfun x =>\n LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f\n LexLeanPreservation.Rust.RepresentableL._f\nLexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile)\n (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value),\n LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort →\n LexLeanTarget.RustSemantics.itemFallible item = false\n","stdout_sha256":"0138aa67a936dd3bb87b7b76f435634a8781058c35c07afe142a86d54eacf9a7","tool":"lean"} diff --git a/features/suites/preservation.feature b/features/suites/preservation.feature index af56a34ce..4178298b4 100644 --- a/features/suites/preservation.feature +++ b/features/suites/preservation.feature @@ -92,3 +92,10 @@ Feature: preservation When the certificates of each root are generated and the list literals they write are counted, and each root is verified with the pinned Lean Then no certificate writes a list literal of more than 32 elements And every root verifies, certificate B included + + @SP-14 @build + Scenario: Certificate E of every production root is kernel-term data: a native core module of schema lexlean/core-module/2 that the compiler builds from the lowered program, the layout, and the recorded types of the preservation library's lemmas, every argument and universe level explicit, which the one core backend renders to the Lean that verification compiles and whose record is the authoring notation, reading back to the data byte for byte; its theorems state what §17.17 states for the composition, each row pins its axioms exactly and the audit module prints and checks them, a certificate held as data is audited row by row and never as text (no axiom row, no forbidden constant, imports within the environment), and a planted wrong lemma, a changed statement, a forged crate reference, or an added axiom is refused. + Given every production root of the committed examples, the lowered programs, and the native preservation library + When certificate E of each root is built as a core module, rendered by the core backend, recorded in the notation, and verified under the pinned Lean + Then the record reads back to the module byte for byte, every row pins its axioms exactly, and the theorems elaborate, replay, and pass the audit + And a wrong lemma application, a changed statement, a forged crate reference, and an added axiom are each refused diff --git a/model/ids.toml b/model/ids.toml index 8671192af..d6150a13f 100644 --- a/model/ids.toml +++ b/model/ids.toml @@ -1910,6 +1910,12 @@ level = "build" suite = "preservation" statement = "Certificate text writes every list and array of any length as a term the pinned Lean elaborates without binders: one of at most 32 elements as a literal and a longer one as a chain of List.cons, so that no certificate holds a literal Lean splits under let binders; a root calling a function of 33 parameters with 33 operands, a root copying a record of 33 fields, and a root matching on 33 constructors of one field each verify through the whole pipeline, and none of their certificates writes a literal of more than 32 elements." +[[id]] +id = "SP-14" +level = "build" +suite = "preservation" +statement = "Certificate E of every production root is kernel-term data: a native core module of schema lexlean/core-module/2 that the compiler builds from the lowered program, the layout, and the recorded types of the preservation library's lemmas, every argument and universe level explicit, which the one core backend renders to the Lean that verification compiles and whose record is the authoring notation, reading back to the data byte for byte; its theorems state what §17.17 states for the composition, each row pins its axioms exactly and the audit module prints and checks them, a certificate held as data is audited row by row and never as text (no axiom row, no forbidden constant, imports within the environment), and a planted wrong lemma, a changed statement, a forged crate reference, or an added axiom is refused." + [[id]] id = "MD-01" level = "build" diff --git a/tests/negative/certificate-e-rejected/expected/command.json b/tests/negative/certificate-e-rejected/expected/command.json index 359663352..d3ad3493b 100644 --- a/tests/negative/certificate-e-rejected/expected/command.json +++ b/tests/negative/certificate-e-rejected/expected/command.json @@ -1 +1 @@ -{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLV7016","help":[],"labels":[],"message":"certificate E: `LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore` was rejected in `root` of root `Production.Main.checkedSum`: error: Application type mismatch: The argument\n rfl\nhas type\n ?m.51 = ?m.51\nbut is expected to have type\n LexLeanPreservation.Rust.fnFallible RustCore.krate 0 = some true\nin the application\n LexLeanPreservation.Rust.compose (fun __e_n => R0.RustCore.root __e_n 0) rfl\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 left)\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 right) LexLeanPreservation.Rust.wtl_nil))\n rfl rfl\n","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":1,"modules":[],"spec":"lexlean/command-result/1","success":false} +{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLV7016","help":[],"labels":[],"message":"certificate E: `LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore` was rejected in `root` of root `Production.Main.checkedSum`: error: native core declaration 'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore.root':\n (kernel) application type mismatch\n LexLeanPreservation.Rust.compose (fun __e_n => RustCore.root __e_n 0)\n (Eq.refl (LexLeanRuntime.index RustCore.program.functions 0))\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 left)\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 right) LexLeanPreservation.Rust.wtl_nil))\n (Eq.refl\n (LexLeanTarget.TargetSemantics.bindAll\n (RustCore.program.functions.getD 0\n { parameters := [], types := [], result := LexLeanTarget.TargetSyntax.Ty.unit,\n body :=\n LexLeanTarget.TargetSyntax.Expr.value LexLeanTarget.TargetSyntax.Ty.unit","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":1,"modules":[],"spec":"lexlean/command-result/1","success":false} diff --git a/tests/negative/certificate-e-rejected/expected/diagnostics.json b/tests/negative/certificate-e-rejected/expected/diagnostics.json index f0d42961c..976b6b97b 100644 --- a/tests/negative/certificate-e-rejected/expected/diagnostics.json +++ b/tests/negative/certificate-e-rejected/expected/diagnostics.json @@ -1 +1 @@ -[{"causes":[],"code":"LLV7016","help":[],"labels":[],"message":"certificate E: `LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore` was rejected in `root` of root `Production.Main.checkedSum`: error: Application type mismatch: The argument\n rfl\nhas type\n ?m.51 = ?m.51\nbut is expected to have type\n LexLeanPreservation.Rust.fnFallible RustCore.krate 0 = some true\nin the application\n LexLeanPreservation.Rust.compose (fun __e_n => R0.RustCore.root __e_n 0) rfl\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 left)\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 right) LexLeanPreservation.Rust.wtl_nil))\n rfl rfl\n","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] +[{"causes":[],"code":"LLV7016","help":[],"labels":[],"message":"certificate E: `LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore` was rejected in `root` of root `Production.Main.checkedSum`: error: native core declaration 'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R0.Compose.RustCore.root':\n (kernel) application type mismatch\n LexLeanPreservation.Rust.compose (fun __e_n => RustCore.root __e_n 0)\n (Eq.refl (LexLeanRuntime.index RustCore.program.functions 0))\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 left)\n (LexLeanPreservation.Rust.wtl_cons (LexLeanPreservation.Rust.wt_u32 right) LexLeanPreservation.Rust.wtl_nil))\n (Eq.refl\n (LexLeanTarget.TargetSemantics.bindAll\n (RustCore.program.functions.getD 0\n { parameters := [], types := [], result := LexLeanTarget.TargetSyntax.Ty.unit,\n body :=\n LexLeanTarget.TargetSyntax.Expr.value LexLeanTarget.TargetSyntax.Ty.unit","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] diff --git a/tests/negative/certificate-e-rejected/toolchain/bin/lake b/tests/negative/certificate-e-rejected/toolchain/bin/lake index 29750e507..3a764fd2d 100755 --- a/tests/negative/certificate-e-rejected/toolchain/bin/lake +++ b/tests/negative/certificate-e-rejected/toolchain/bin/lake @@ -4,14 +4,18 @@ # the other result shape (`R` for a plain function and a plain result for # a fallible one): certificates A and B still hold, but no composition of # them proves the restatement, and verification refuses it (SPEC.md 17.17). +# The certificate is kernel-term data rendered by the core backend, so the +# swap is made in the data the Lean text carries: the constant node of the +# fallibility flag, {"k":"c","n":"Bool.true","u":[]}, which the statement +# and the proof share. real="$(dirname "$(readlink -f "$(dirname "$0")/lean")")/lake" if [ "$1" = "env" ] && [ "$2" = "lean" ]; then for source; do :; done case "$source" in */preserve-src/LexLeanPreserve/C*/R*/Compose/Rust*.lean) - sed -e 's/RealizesFn Bool\.true /RealizesFn swapped /' \ - -e 's/RealizesFn Bool\.false /RealizesFn Bool.true /' \ - -e 's/RealizesFn swapped /RealizesFn Bool.false /' "$source" > "$source.tmp" && mv "$source.tmp" "$source" + sed -e 's/\\"n\\":\\"Bool\.true\\"/\\"n\\":\\"Bool.swapped\\"/g' \ + -e 's/\\"n\\":\\"Bool\.false\\"/\\"n\\":\\"Bool.true\\"/g' \ + -e 's/\\"n\\":\\"Bool\.swapped\\"/\\"n\\":\\"Bool.false\\"/g' "$source" > "$source.tmp" && mv "$source.tmp" "$source" ;; esac fi diff --git a/tests/negative/certificates-total-limit/expected/command.json b/tests/negative/certificates-total-limit/expected/command.json index 669438e12..e540a4ee5 100644 --- a/tests/negative/certificates-total-limit/expected/command.json +++ b/tests/negative/certificates-total-limit/expected/command.json @@ -1 +1 @@ -{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLS8002","help":[],"labels":[],"message":"max_total_source_bytes exceeded in phase certificates: configured 2000000, the programs, crates, and certificates generated so far are 2024021 bytes once root `Production.Main.r25` has generated its certificates B and E and its crates","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":4,"modules":[],"spec":"lexlean/command-result/1","success":false} +{"artifacts":[],"command":"verify","diagnostics":[{"causes":[],"code":"LLS8002","help":[],"labels":[],"message":"max_total_source_bytes exceeded in phase certificates: configured 2000000, the programs, crates, and certificates generated so far are 2022504 bytes once root `Production.Main.r14` has generated its certificates B and E and its crates","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}],"exit_code":4,"modules":[],"spec":"lexlean/command-result/1","success":false} diff --git a/tests/negative/certificates-total-limit/expected/diagnostics.json b/tests/negative/certificates-total-limit/expected/diagnostics.json index 34e0bcbb6..74fa09c14 100644 --- a/tests/negative/certificates-total-limit/expected/diagnostics.json +++ b/tests/negative/certificates-total-limit/expected/diagnostics.json @@ -1 +1 @@ -[{"causes":[],"code":"LLS8002","help":[],"labels":[],"message":"max_total_source_bytes exceeded in phase certificates: configured 2000000, the programs, crates, and certificates generated so far are 2024021 bytes once root `Production.Main.r25` has generated its certificates B and E and its crates","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] +[{"causes":[],"code":"LLS8002","help":[],"labels":[],"message":"max_total_source_bytes exceeded in phase certificates: configured 2000000, the programs, crates, and certificates generated so far are 2022504 bytes once root `Production.Main.r14` has generated its certificates B and E and its crates","notes":[],"primary":{"byte_end":0,"byte_start":0,"column_end":1,"column_start":1,"line_end":1,"line_start":1,"path":"lexlean.toml"},"severity":"error","spec":"lexlean/diagnostic/1"}] diff --git a/tests/preservation-certificates/E-STATEMENTS.md b/tests/preservation-certificates/E-STATEMENTS.md new file mode 100644 index 000000000..071fc5958 --- /dev/null +++ b/tests/preservation-certificates/E-STATEMENTS.md @@ -0,0 +1,148 @@ +# Certificate E as data: the statements are the text's + +Certificate E of every production root was Lean text written by +`production/certificate.rs`. It is now kernel-term data: a native core module +of schema `lexlean/core-module/2` the compiler builds and the one core backend +renders (SPEC.md §17.17, `SP-14`; stage 1 of #89). This record is the evidence +that the change kept every statement: for each theorem of each data +certificate, the kernel term it states is definitionally the kernel term the +committed text certificate elaborated to, under the pinned Lean 4.32.1. + +## How it was checked + +At the branch's commit `1314d976`, before the verify records were regenerated, +the committed records of the four corpora still held the text certificates E +(`examples//expected/verify/preserve/LexLeanPreserve/C/R/Compose/Rust*.lean`). +For each corpus the oracle: + +1. built every root's certificates (A and B as text, E as data) with + `repo_conformance::preservation::certificates`, staged them with the + environment and the project's generated modules, and compiled and replayed + every module with the pinned Lean (`preservation::check`), so that every + data certificate E was in the environment under its own name; +2. compiled the committed text certificate E of the same root and target + beside it, its namespace renamed from `` to `.Old` (the + two lines `namespace ` and `end `; every other name of the + text is absolute or resolves inside the renamed namespace); +3. compiled an oracle module importing both, which, for every row of the data + certificate (`__wt_k`, `__wtItems_n`, `__wtAux_n`, `root`), compares the + type of `.` with the type of `.Old.` by + `Lean.Meta.isDefEq` and fails on the first pair that differs: + +```lean +import +import .Old +import Lean +open Lean Meta +run_cmd Lean.Elab.Command.liftTermElabM do + let pairs : List (Name × Name) := [(`.__wt_0, `.Old.__wt_0), …, (`.root, `.Old.root)] + for (new, old) in pairs do + let n ← getConstInfo new + let o ← getConstInfo old + unless (← isDefEq n.type o.type) do + throwError "{new}: the statement differs from {old}" + logInfo m!"SP-14 oracle: {pairs.length} statements equal" +``` + +The oracle was the test `oracle_e_statements` in +`crates/conformance/src/preservation.rs` at that commit, run as +`cargo test -p repo-conformance --lib oracle_e_statements -- --ignored --nocapture` +on Linux x86-64 with the pinned toolchain; it was removed once this record was +written, as the library exporter was after `tests/preservation-library/MIGRATION.md`. + +## Result + +Oracle run on 2026-10-15 at commit `1314d976` (the branch before the records were regenerated), Lean 4.32.1, Linux x86-64: 76 certificates E, 131 theorem rows, every pair definitionally equal (`isDefEq`), 655 s. + +| corpus | certificates E | +| --- | ---: | +| `production` | 10 | +| `production-coverage` | 49 | +| `models` | 9 | +| `reasoning` | 8 | + +Every certificate, by module (the rows of a certificate are its `__wt_k`, `__wtItems_n`, `__wtAux_n`, and `root` theorems): + +| corpus | certificate E | rows | oracle | +| --- | --- | ---: | --- | +| `production` | `C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production` | `C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production` | `C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore` | 2 | SP-14 oracle: 2 statements equal | +| `production` | `C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd` | 2 | SP-14 oracle: 2 statements equal | +| `production` | `C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production` | `C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production` | `C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production` | `C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production` | `C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production` | `C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd` | 8 | SP-14 oracle: 8 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore` | 2 | SP-14 oracle: 2 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd` | 2 | SP-14 oracle: 2 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd` | 2 | SP-14 oracle: 2 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore` | 4 | SP-14 oracle: 4 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd` | 4 | SP-14 oracle: 4 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd` | 3 | SP-14 oracle: 3 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd` | 4 | SP-14 oracle: 4 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `production-coverage` | `C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd` | 2 | SP-14 oracle: 2 statements equal | +| `models` | `Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd` | 2 | SP-14 oracle: 2 statements equal | +| `models` | `Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd` | 2 | SP-14 oracle: 2 statements equal | +| `models` | `Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd` | 3 | SP-14 oracle: 3 statements equal | +| `models` | `Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd` | 2 | SP-14 oracle: 2 statements equal | +| `models` | `Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd` | 2 | SP-14 oracle: 2 statements equal | +| `models` | `Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `models` | `Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `models` | `Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `models` | `Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd` | 1 | SP-14 oracle: 1 statements equal | +| `reasoning` | `C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore` | 4 | SP-14 oracle: 4 statements equal | +| `reasoning` | `C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore` | 4 | SP-14 oracle: 4 statements equal | +| `reasoning` | `C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd` | 6 | SP-14 oracle: 6 statements equal | +| `reasoning` | `C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd` | 5 | SP-14 oracle: 5 statements equal | +| `reasoning` | `C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd` | 3 | SP-14 oracle: 3 statements equal | +| `reasoning` | `C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore` | 4 | SP-14 oracle: 4 statements equal | +| `reasoning` | `C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd` | 5 | SP-14 oracle: 5 statements equal | +| `reasoning` | `C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd` | 2 | SP-14 oracle: 2 statements equal | + +Every statement of every certificate E is the statement the text stated. What +changed is the proof term (now written with every argument, by the data +generator) and the form of the module (kernel data rendered by the decoder, in +place of Lean source text); what a verification establishes of a root did not. diff --git a/xtask/src/spec_links.rs b/xtask/src/spec_links.rs index 227af7d2f..462cc4c5b 100644 --- a/xtask/src/spec_links.rs +++ b/xtask/src/spec_links.rs @@ -61,8 +61,8 @@ fn parse_table(spec: &str) -> Result, Fail> { pub fn validate(root: &Path) -> Result<(), Fail> { let spec = std::fs::read_to_string(root.join("SPEC.md"))?; let rows = parse_table(&spec)?; - if rows.len() != 391 { - return Err(format!("RP-07: the §31 table has {} rows, not 391", rows.len()).into()); + if rows.len() != 392 { + return Err(format!("RP-07: the §31 table has {} rows, not 392", rows.len()).into()); } // The prose total under the table is part of the contract a reader // relies on; a row added without it would leave §31 contradicting itself.